1 /*

     2 * Copyright (c) 2002-2010 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 <apacmdln.h>

    31 #include <apgtask.h>

    32 #include <bautils.h>

    33 #include <textresolver.h>

    34 #include <charconv.h>

    35 #include <gsmuelem.h>

    36 #include <exterror.h>

    37 #include <rmmcustomapi.h>

    38 

    39 #include <w32std.h>

    40 #include <apgcli.h>

    41 #include <cphcltussd.h> 

    42 #include <hbtextresolversymbian.h>

    43 #include <phoneserver.rsg> 

    44 #include "phsrvdebuginfo.h" 

    45 #include <e32property.h>

    46 #include <centralrepository.h>

    47 #include <coreapplicationuisdomainpskeys.h>

    48 

    49 

    50 // CONSTANTS

    51 const TInt KPhSrvDefaultValue = 0x00000000;

    52 // See SharedDataKeysVariant.h or NcnListInternalPSKeys.h

    53 // const TInt KPhSrvUssdNoTone = 0; 

    54 // const TInt KPhSrvUssdTimeOutObserverGranularity = 2;

    55 // const TInt KPhSrvUssdSentMessageObserverGranularity = 2;

    56 // See KUssdSecureId in phcltclientserver.h

    57 //const TInt KPhSrvUssdAppUID = 0x10005955; 

    58 

    59 const TInt KPhSrvUssdMessageQueryInterval = 500000; // 0.5 sec

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

    61 //

    62 const TUint KPhSrvUssdDefaultDCS = 0x0f;                        // 00001111

    63 

    64 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguage = 0x10;// 00010000

    65 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars3 = 3;

    66 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageSkipChars2 = 2;

    67 const TUint KPhSrvUssdDcsAlphabetDefaultPrecededLanguageStartBit = 5;

    68 

    69 const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguage = 0x11;   // 00010001

    70 const TUint KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars = 2;

    71 

    72 const TUint KPhSrvUssdDcsGeneralInformationMask = 0xc0;         // 11000000

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

    74 const TUint KPhSrvUssdDcsGeneralInformationCompressed = 0x20;   // xx1xxxxx

    75 const TUint KPhSrvUssdDcsGeneralInformationSimMask = 0x13;      // 00010011

    76 const TUint KPhSrvUssdDcsGeneralInformationSim = 0x12;          // xxx1xx10

    77 const TUint KPhSrvUssdDcsGeneralInformationAlphabetMask = 0x0c; // 00001100

    78 const TUint KPhSrvUssdDcsGeneralInformationAlphabet8Bit = 0x04; // xxxx01xx

    79 const TUint KPhSrvUssdDcsGeneralInformationAlphabetUCS2 = 0x08; // xxxx10xx

    80 

    81 const TUint KPhSrvUssdDcsMessageHandlingAlphabetMask = 0xf4;    // 11110100

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

    83 const TInt KPhrUssdNotifyArraySize = 1;

    84 

    85 // Refers to HbPopup::NoDismiss = 0

    86 const TInt KPhSrvUssdPopupDismissPolicy = 0; 

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

    88 const TUint KPhSrvUssdTimeout = 300000000;

    89 

    90 // Use QT style localization

    91 _LIT(KUssdLocFilename, "ussd_");

    92 _LIT(KCommonLocFilename, "common_");

    93 _LIT(KLocPath, "z:\\resource\\qt\\translations");

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

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

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

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

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

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

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

   101 _LIT(KUssdConfirm, "txt_ussd_info_there_are_still_unread_notifications");

   102 

   103 // MACROS

   104 

   105 #define _DPRINT_FLAGS() \

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

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

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

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

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

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

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

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

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

   115 

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

   117 

   118 // CLASS DECLARATION

   119 

   120 #ifndef TPHSRVUSSDALPHABETPACKER_H

   121 #define TPHSRVUSSDALPHABETPACKER_H

   122 

   123 // CONSTANTS

   124 const TUint8 KPhSrvUssdCarriageReturn = 0x0d;

   125 

   126 /**

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

   128 *

   129 *  @since 1.0

   130 */

   131 class TPhSrvUssdAlphabetPacker

   132     {

   133     public:  // Constructors and destructor

   134 

   135         /**

   136         * Constructor.

   137         *

   138         * @param aAlphabet The alphabet that is used.

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

   140         * @param aStartBit The start bit for conversion.

   141         */

   142         TPhSrvUssdAlphabetPacker(

   143             TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

   144             TBool aIsBinary,

   145             TInt aStartBit );

   146 

   147 

   148     public: // New functions

   149 

   150         /**

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

   152         *

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

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

   155         * @param aNumUDUnits Buffer length.

   156         * @return Length of the result buffer.

   157         */

   158         TInt UnpackL(

   159             const TDesC8& aIn,

   160             TDes8& aOut,

   161             TInt aNumUDUnits );

   162 

   163         /**

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

   165         *

   166         * @param aCharacterSetConverter Does the converting.

   167         * @param aFs File server session.

   168         * @param aIn Packed 7-bit buffer.

   169         * @param aOut Unicode buffer.

   170         * @param aNumUDUnits Number of charahters.

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

   172         */

   173         TInt UnpackAndConvertL(

   174             CCnvCharacterSetConverter& aCharacterSetConverter,

   175             RFs& aFs,

   176             const TDesC8& aIn,

   177             TDes& aOut,

   178             TInt aNumUDUnits );

   179 

   180         /**

   181         * Counts the needed octet amout.

   182         *

   183         * @param aNumUDUnits Number of source characters.

   184         * @return Octets needed.

   185         */

   186         TInt PackedOctetsRequiredL( TInt aNumUDUnits ) const;

   187 

   188 

   189     private:

   190 

   191         // Private helper methods

   192         TInt ElementSizeInBitsL() const;

   193 

   194 

   195     private:    // Data

   196 

   197         // The used coding alphabet.

   198         TSmsDataCodingScheme::TSmsAlphabet iAlphabet;

   199 

   200         // Is the packed data binary.

   201         TBool iIsBinary;

   202 

   203         // The start bit for packing.

   204         TInt iStartBit;

   205     };

   206 

   207 #endif // TPHSRVUSSDALPHABETPACKER_H

   208 

   209 

   210 // -----------------------------------------------------------------------------

   211 // TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker

   212 // Constructor.

   213 //

   214 // -----------------------------------------------------------------------------

   215 //

   216 TPhSrvUssdAlphabetPacker::TPhSrvUssdAlphabetPacker(

   217     TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

   218     TBool aIsBinary,

   219     TInt aStartBit)

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

   221     {

   222     }

   223 

   224 

   225 // -----------------------------------------------------------------------------

   226 // TPhSrvUssdAlphabetPacker::UnpackL

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

   228 //

   229 // -----------------------------------------------------------------------------

   230 //

   231 TInt TPhSrvUssdAlphabetPacker::UnpackL(

   232     const TDesC8& aIn,

   233     TDes8& aOut,

   234     TInt aNumUDUnits )

   235     {

   236     TInt length = aNumUDUnits;

   237     // Ensure we've got enough  output buffer

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

   239         {

   240         User::Leave(KErrCorrupt);

   241         }

   242 

   243     TInt elementSizeInBits = ElementSizeInBitsL();

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

   245         {

   246         aOut.Append( aIn );

   247         }

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

   249         {

   250         // Get raw pointers and do unpacking

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

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

   253 

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

   255             {

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

   257             if ( iStartBit )

   258                 {

   259                 inPtr++;

   260                 // Take more from next byte

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

   262                 }

   263             outPtr[i] = ( TUint8 ) from;

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

   265             }

   266 

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

   268         // on an octet bounday with CR.

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

   270             {

   271             length--;

   272             }

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

   274         }

   275     else

   276         {

   277         __ASSERT_DEBUG(EFalse,

   278             PhoneServerUtils::Panic( EPhoneServerPanicModeLogicFault ) );

   279         }

   280     return length;

   281     }

   282 

   283 

   284 // -----------------------------------------------------------------------------

   285 // TPhSrvUssdAlphabetPacker::UnpackAndConvertL

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

   287 //

   288 // -----------------------------------------------------------------------------

   289 //

   290 TInt TPhSrvUssdAlphabetPacker::UnpackAndConvertL(

   291     CCnvCharacterSetConverter& aCharacterSetConverter,

   292     RFs& aFs,

   293     const TDesC8& aIn,

   294     TDes& aOut,

   295     TInt aNumUDUnits )

   296     {

   297 

   298     // Unpack first

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

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

   301     UnpackL( aIn, unpackedBufferPtr,aNumUDUnits );

   302 

   303     // Convert

   304     CSmsAlphabetConverter* converter =

   305         CSmsAlphabetConverter::NewLC(

   306             aCharacterSetConverter, aFs, iAlphabet, iIsBinary );

   307 

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

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

   310         {

   311         User::Leave( KErrCorrupt );

   312         }

   313     // Cleanup and return

   314     aOut.Append( convertedPtr );

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

   316     return aNumUDUnits;

   317     }

   318 

   319 

   320 // -----------------------------------------------------------------------------

   321 // TPhSrvUssdAlphabetPacker::PackedOctetsRequiredL

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

   323 //

   324 // -----------------------------------------------------------------------------

   325 //

   326 TInt TPhSrvUssdAlphabetPacker::PackedOctetsRequiredL( TInt aNumUDUnits ) const

   327 

   328     {

   329     TInt octetsRequired = 0;

   330     TInt elementSizeInBits = ElementSizeInBitsL();

   331     if ( elementSizeInBits == 8 )

   332         {

   333         octetsRequired=aNumUDUnits;

   334         }

   335     else

   336         {

   337         octetsRequired =

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

   339         }

   340     return octetsRequired;

   341     }

   342 

   343 // -----------------------------------------------------------------------------

   344 // TPhSrvUssdAlphabetPacker::ElementSizeInBitsL

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

   346 // invalid data coding scheme.

   347 // -----------------------------------------------------------------------------

   348 //

   349 TInt TPhSrvUssdAlphabetPacker::ElementSizeInBitsL() const

   350     {

   351     if (iIsBinary)

   352         return 8;

   353     switch ( iAlphabet )

   354         {

   355         case TSmsDataCodingScheme::ESmsAlphabet7Bit:

   356             {

   357             return 7;

   358             }

   359         case TSmsDataCodingScheme::ESmsAlphabet8Bit:

   360         case TSmsDataCodingScheme::ESmsAlphabetUCS2:

   361             {

   362             return 8;

   363             }

   364         default:

   365             {

   366             User::Leave(KErrGsmSMSDataCodingSchemeNotSupported);

   367             return 8;

   368             }

   369         }

   370     }

   371 

   372 

   373 

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

   375 

   376 // -----------------------------------------------------------------------------

   377 // CPhSrvUssdManager::CPhSrvUssdManager

   378 //

   379 // Constructor

   380 //

   381 // -----------------------------------------------------------------------------

   382 //

   383 CPhSrvUssdManager::CPhSrvUssdManager(

   384     RFs& aFsSession,

   385     CPhSrvResourceManager& aResourceManager

   386     )

   387     :CActive( EPriorityLow ),

   388      iFsSession( aFsSession ),

   389      iResourceManager( aResourceManager ),

   390      iDeviceDialog( NULL ),

   391      iDCS ( KPhCltDcsUnknown ),

   392      iReturnResultPckg ( iReturnResult ),

   393      iTextBuffer ( NULL )

   394     {

   395     CActiveScheduler::Add( this );

   396     }

   397 

   398 

   399 // -----------------------------------------------------------------------------

   400 // CPhSrvUssdManager::~CPhSrvUssdManager

   401 //

   402 // Destructor

   403 //

   404 // -----------------------------------------------------------------------------

   405 //

   406 CPhSrvUssdManager::~CPhSrvUssdManager()

   407     {

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

   409 

   410 

   411     delete iUssdSendHandler;

   412     iUssdSendHandler = NULL;

   413 

   414     delete iUssdReceiveHandler;

   415     iUssdReceiveHandler = NULL;

   416 

   417     delete iUssdNotifyNWRelease;

   418     iUssdNotifyNWRelease = NULL;

   419 

   420     Cancel();

   421 

   422     iTimer.Close();

   423     

   424     delete iTextBuffer;

   425     iTextBuffer = NULL;

   426     

   427     delete iDeviceDialog;

   428     iDeviceDialog = NULL;

   429 

   430     if ( iNotifyArray )

   431         {

   432         iNotifyArray->Reset();

   433         }

   434     delete iNotifyArray;

   435     if ( iUssdReplyTimer )

   436         {

   437         iUssdReplyTimer->Stop();

   438         }

   439     delete iUssdReplyTimer;

   440     iUssdReplyTimer = NULL;

   441 

   442     iFsSession.Close();

   443 

   444     iMobileUssdMessaging.Close();

   445     

   446     delete iMoAckCallback;

   447 

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

   449     }

   450 

   451 

   452 // -----------------------------------------------------------------------------

   453 // CPhSrvUssdManager::ConstructL

   454 //

   455 // Symbian OS 2nd phase constructor

   456 //

   457 // -----------------------------------------------------------------------------

   458 //

   459 void CPhSrvUssdManager::ConstructL( MPhSrvPhoneInterface& aPhoneInterface )

   460     {

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

   462     const TBool textResolver = HbTextResolverSymbian::Init( 

   463         KUssdLocFilename, KLocPath );

   464     _DDPRINT( 4, "PhSrv.ConstructL.ussd loc:", textResolver );

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

   466 

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

   468 

   469     // Check support

   470     RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   471     RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

   473 

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

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

   476         {

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

   478         iUssdReceiveHandler = new( ELeave ) CPhSrvUssdReceiveHandler(

   479             *this,

   480             iMobileUssdMessaging );

   481         iUssdReceiveHandler->ConstructL();

   482 

   483         iUssdNotifyNWRelease = new( ELeave )  CPhSrvUssdNotifyNWRelease(

   484             *this,

   485             iMobileUssdMessaging );

   486 

   487         iUssdNotifyNWRelease->ConstructL();

   488         }

   489 

   490     iPhoneInterface = &aPhoneInterface;

   491 

   492     SendHandlerL();

   493     

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

   495 

   496     iVariantReadOnlyValues = KPhSrvDefaultValue;

   497 

   498     User::LeaveIfError( GetTelephonyVariantData() );

   499 

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

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

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

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

   504     }

   505 

   506 

   507 // -----------------------------------------------------------------------------

   508 // CPhSrvUssdManager::SendHandlerL

   509 //

   510 // The send handler.

   511 //

   512 // -----------------------------------------------------------------------------

   513 //

   514 CPhSrvUssdSendHandler& CPhSrvUssdManager::SendHandlerL()

   515     {

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

   517     // is supported by the TSY.

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

   519     if ( iUssdSendHandler == NULL )

   520         {

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

   522         RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   523         RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

   525         _DPRINT( 4, "PhSrv.SendHandlerL.iMobileUssdMessaging.GetCaps" );

   526 

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

   528             ( caps.iUssdFormat & RMobileUssdMessaging::KCapsPackedString )

   529             == 0 )

   530             {

   531             _DPRINT( 4, "PhSrv.SendHandlerL.KErrNotSupported" );

   532             User::Leave( KErrNotSupported );

   533             }

   534 

   535         iUssdSendHandler =

   536             new( ELeave ) CPhSrvUssdSendHandler(

   537                 *this,

   538                 iMobileUssdMessaging,

   539                 *iPhoneInterface );

   540         }

   541     _DPRINT( 4, "PhSrv.SendHandlerL.End" );

   542     return *iUssdSendHandler;

   543     }

   544 

   545 

   546 // -----------------------------------------------------------------------------

   547 // CPhSrvUssdManager::SendUssdL

   548 //

   549 // Send the USSD message.

   550 //

   551 // -----------------------------------------------------------------------------

   552 //

   553 void CPhSrvUssdManager::SendUssdL(

   554     const TDesC8& aMsgData,

   555     RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttribute,

   556     MPhSrvUssdMessageSentObserver& aObserver )

   557     {

   558     _DPRINT( 4, "PhSrv.SendUssdL.Start ######" );

   559     _DPRINT_FLAGS();

   560     

   561     if ( iObserver && iNetworkReleased ) 

   562         {

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

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

   565         // and clean up the pointer.

   566         _DPRINT( 4, "PhSrv.SendUssdL.Error.Complete.Existing" );

   567         if ( iUssdSendHandler ) 

   568             {

   569             iUssdSendHandler->Cancel();

   570             }

   571         iObserver->UssdMessageSentObserverHandleResult( KErrSessionClosed );

   572         iObserver = NULL;

   573         }

   574     

   575     if ( iObserver || iSendingAck )

   576         {

   577         _DPRINT( 4, "PhSrv.SendUssdL.KErrInUse" );

   578         // Other client is using the service.

   579         User::Leave( KErrInUse );

   580         }

   581 

   582     // Check that message type is set

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

   584         == 0 )

   585         _DPRINT( 4, "PhSrv.SendUssdL.KUssdMessageType.0" );

   586         {

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

   588         aMsgAttribute.iFlags |= RMobileUssdMessaging::KUssdMessageType;

   589         if ( NetworkWaitingForAnAnswer() )

   590             {

   591             // Network is waiting for an answer

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

   593             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMOReply;

   594             }

   595         else

   596             {

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

   598             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMORequest;

   599             }

   600         }

   601         

   602     RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attribs( aMsgAttribute );

   603     iShowDone = ETrue;

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

   605     _DPRINT( 4, "PhSrv.SendUssdL.Send" );

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

   607     iObserver = &aObserver;

   608     // Not closing nor closed anymore

   609     iNetworkReleased = EFalse;

   610     iSendRelease = EFalse;

   611     iClearArray = EFalse;

   612     

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

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

   615     if ( NetworkWaitingForAnAnswer() )

   616         {

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

   618         iUssdReplyTimer->Stop();

   619         }

   620     _DPRINT( 4, "PhSrv.SendUssdL.End" );

   621     }

   622 

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

   624 // CPhSrvUssdManager::NetworkWaitingForAnAnswer

   625 // -----------------------------------------------------------------------------

   626 //

   627 TBool CPhSrvUssdManager::NetworkWaitingForAnAnswer() 

   628     {

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

   630     }

   631 // -----------------------------------------------------------------------------

   632 // CPhSrvUssdManager::SendUssdCancel

   633 //

   634 // Cancel the USSD sending.

   635 //

   636 // -----------------------------------------------------------------------------

   637 //

   638 void CPhSrvUssdManager::SendUssdCancel()

   639     {

   640     _DPRINT( 4, "PhSrv.SendUssdCancel.Start #######" );

   641 

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

   643     // the whole session

   644     _DPRINT_FLAGS();

   645     if ( !iSendingAck || iSendRelease ) 

   646         {

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

   648         iUssdSendHandler->SendUssdCancel();

   649         }

   650 

   651     if ( iHavePendingSatMessagePointer )

   652         {

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

   654         iSatCanceled = ETrue;

   655         }

   656     iObserver = NULL;

   657     

   658     SetActiveIfPendingNotificationsExist();

   659     _DPRINT( 4, "PhSrv.SendUssdCancel.End" );

   660     }

   661 

   662 // -----------------------------------------------------------------------------

   663 // CPhSrvUssdManager::SetActiveIfPendingNotificationsExist

   664 // -----------------------------------------------------------------------------

   665 //

   666 void CPhSrvUssdManager::SetActiveIfPendingNotificationsExist()

   667     {

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

   669         {

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

   671         iLaunchGMQ = ETrue;

   672         iNotifyMessage = ETrue;

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

   674         iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   675         SetActive();

   676         _DPRINT_FLAGS();

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

   678         }

   679     }

   680 // -----------------------------------------------------------------------------

   681 // CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL

   682 //

   683 //

   684 //

   685 // -----------------------------------------------------------------------------

   686 //

   687 void CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL( TInt aError )

   688     {

   689     // debug print

   690     _DDPRINT(

   691         4,

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

   693         aError );

   694 

   695     // complete SAT if needed

   696     if ( aError < KErrNone )

   697         {

   698  

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

   700         CompleteSatL( NULL, aError );

   701         }

   702 

   703     if ( iObserver )

   704         {

   705  

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

   707 

   708         iObserver->UssdMessageSentObserverHandleResult( aError );

   709         iObserver = NULL;

   710         }

   711     

   712     iSendingAck = EFalse;

   713     

   714     AsyncProcessMoAcks();

   715     

   716     // debug print

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

   718     }

   719 

   720 

   721 // -----------------------------------------------------------------------------

   722 // CPhSrvUssdManager::UssdAppTaskExists

   723 //

   724 //

   725 //

   726 // -----------------------------------------------------------------------------

   727 //

   728 TBool CPhSrvUssdManager::UssdAppTaskExistsL()

   729 {   

   730     TBool ret = EFalse;

   731     RWsSession wsSession;

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

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

   734     CleanupClosePushL(wsSession);

   735     TApaTaskList tasklist(wsSession);

   736     TApaTask task = tasklist.FindApp( KUssdSecureId );

   737     ret = task.Exists();

   738 

   739     CleanupStack::PopAndDestroy();

   740     return ret;

   741 }

   742 

   743 // -----------------------------------------------------------------------------

   744 // CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL

   745 //

   746 //

   747 //

   748 // -----------------------------------------------------------------------------

   749 //

   750 void CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL(

   751     const TDes8& aMsgData,

   752     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes,

   753     TInt aError )

   754     {

   755     _DDPRINT(

   756         4,

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

   758         aError );

   759     _DPRINT_FLAGS();

   760     if ( aError != KErrNone )

   761         {

   762         TurnLightsOn(); //Ensure lights on

   763  

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

   765         ShowErrorNoteL( aError );

   766         }

   767     else if ( iSendRelease )

   768         {

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

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

   771         }

   772     else

   773         {

   774         UssdHandleReceivedEventL( aMsgData, aMsgAttributes );

   775         }

   776     }

   777 

   778 // -----------------------------------------------------------------------------

   779 // CPhSrvUssdManager::UssdHandleReceivedEventL

   780 // -----------------------------------------------------------------------------

   781 //

   782 void CPhSrvUssdManager::UssdHandleReceivedEventL(

   783     const TDes8& aMsgData,

   784     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes )

   785     {

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

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

   788     iNetworkReleased = EFalse;

   789         

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

   791     if ( iObserver )

   792         {

   793  

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

   795         UssdNetworkObserverHandleSendEventL( 1 ); // some positive value

   796         }

   797     

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

   799          aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest )

   800         {

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

   802         RestartReplyTimerL();

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

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

   805         }

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

   807     TUint8 dcs = KPhSrvUssdDefaultDCS;

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

   809         {

   810         dcs = aMsgAttributes.iDcs;

   811         }

   812     iDecodedMessage.Zero();

   813     iReceivedMessage.Zero();

   814     DecodeL(aMsgData, iDecodedMessage, dcs);

   815     if(iDecodedMessage.Length() > 0)

   816         {

   817         iReceivedMessage = iDecodedMessage;

   818         }

   819     // 5. Show note.

   820     // debug print

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

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

   823             aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )

   824         {

   825         if ( !ShowNotesL() )

   826             {

   827      

   828             _DPRINT( 4,

   829                 "PhSrv.UssdHandleReceivedEventL.SAtReturn" );

   830             return;

   831             }

   832         }

   833 

   834     // empty string is handled as ok message

   835     if ( !iDecodedMessage.Length() )

   836         {

   837         TurnLightsOn(); //Ensure lights on

   838  

   839         _DPRINT( 4,

   840             "PhSrv.UssdHandleReceivedEventL.EmptyString" );

   841         

   842         ShowDoneNoteL();

   843 

   844  

   845         _DPRINT( 4,

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

   847         }

   848     else

   849         {

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

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

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

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

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

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

   856         

   857         if ( iNotifyMessage ) 

   858             {

   859             // need to send an MO ack

   860             iAcksToBeSent ++;

   861             }

   862         

   863         if ( !iDeviceDialog  ){

   864             iDeviceDialog = CHbDeviceMessageBoxSymbian::NewL(

   865                 CHbDeviceMessageBoxSymbian::EInformation );

   866             iDeviceDialog->SetObserver( this );

   867             iDeviceDialog->SetTimeout( KPhSrvUssdTimeout );

   868             iDeviceDialog->SetDismissPolicy ( KPhSrvUssdPopupDismissPolicy );

   869             

   870             // Show left key with empty string accoring to ui concept

   871             iDeviceDialog->SetButton( 

   872                 CHbDeviceMessageBoxSymbian::EAcceptButton, EFalse );

   873             // Show Exit Key always

   874             iDeviceDialog->SetButton( 

   875                 CHbDeviceMessageBoxSymbian::ERejectButton, ETrue );

   876             iDeviceDialog->SetButtonTextL(

   877                 CHbDeviceMessageBoxSymbian::ERejectButton, 

   878                 LoadDefaultString( KUssdExit ) );

   879             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.Exit" );             

   880         }

   881       

   882         if ( iNotifyMessage || iMsgTypeReply )

   883             {

   884             //This is for reply message in notifyarray

   885             iNotifyMessage = ETrue;

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

   887 

   888             //Notify added to array

   889             iNotifyArray->AppendL( iReceivedMessage );

   890 

   891             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.AppendL" );

   892             UpdateNotifyMessageL();

   893 

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

   895                 {

   896                 _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.!SendRelease.Cancel" );

   897                 Cancel();

   898                 }

   899             }

   900         else

   901             {

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

   903             Cancel();

   904             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.NewAnswerable" );

   905             }

   906 

   907         // Remove Reply key

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

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

   910             {

   911             // Remove Answer key

   912             iDeviceDialog->SetButton( 

   913                 CHbDeviceMessageBoxSymbian::EAcceptButton, EFalse );

   914             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.NoAnswer" ); 

   915             }

   916         // Show Reply key

   917         else

   918             {

   919             iDeviceDialog->SetButton( 

   920                 CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue );              

   921             iDeviceDialog->SetButtonTextL(

   922                 CHbDeviceMessageBoxSymbian::EAcceptButton, 

   923                 LoadDefaultString( KUssdReply ) ); 

   924             _DPRINT( 4, "PhSrv.UssdHandleReceivedEventL.WithAnswer" ); 

   925             }

   926 

   927  

   928         _DPRINT( 4,

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

   930 

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

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

   933         // <-- QT PHONE START-->

   934         /*

   935         if ( IsTelephonyFeatureSupported( KTelephonyLVFlagUssdTone ) )

   936             {

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

   938             PlayUssdTone();

   939             }

   940         */

   941             // <-- QT PHONE END-->

   942         // Launch the new message query

   943         if ( !IsActive() )

   944             {

   945             iLaunchGMQ = ETrue;

   946             iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   947             SetActive();

   948             }

   949         AsyncProcessMoAcks();

   950         }

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

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

   953         {

   954         iEmptyEditor = ETrue;

   955         }

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

   957     }

   958 

   959 // -----------------------------------------------------------------------------

   960 // CPhSrvUssdManager::RestartReplyTimerL

   961 //

   962 //

   963 //

   964 // -----------------------------------------------------------------------------

   965 //

   966 void CPhSrvUssdManager::RestartReplyTimerL()

   967     {

   968     if ( iUssdReplyTimer )

   969         {

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

   971         iUssdReplyTimer->Stop();

   972         }

   973 

   974     if ( !iUssdReplyTimer )

   975         {

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

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

   978         }

   979     

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

   981     iUssdReplyTimer->Start();

   982     }

   983 

   984 // -----------------------------------------------------------------------------

   985 // CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL

   986 //

   987 //

   988 //

   989 // -----------------------------------------------------------------------------

   990 //

   991 void CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL(

   992 const RMobilePhone::TMobilePhoneSendSSRequestV3 & aReturnResult,

   993 TInt aError )

   994     {

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

   996     _DPRINT_FLAGS();

   997     TBool showNotes = ShowNotesL();

   998     iNetworkReleased = ETrue;

   999     iSendingAck = EFalse;

  1000     iSendRelease = EFalse;

  1001     iAcksToBeSent = 0;

  1002     

  1003     if ( iHavePendingSatMessagePointer )

  1004         {

  1005         iReturnResult = aReturnResult;

  1006         if ( !iSatCanceled )

  1007             {

  1008             CompleteSatL(&iReceivedMessage, aError );

  1009             _DPRINT( 4, "PhSrv.UssdNetworkObserverHandleNotifyNWReleaseL.CompleteSat" );

  1010             }

  1011         }

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

  1013         {

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

  1015         iUssdReplyTimer->Stop();

  1016         Cancel();

  1017         CheckArray();

  1018         }

  1019     if ( showNotes && iShowDone )

  1020         {

  1021         ShowDoneNoteL();

  1022         }

  1023     if ( iUssdSendHandler && iSendingAck ) 

  1024         {

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

  1026         iUssdSendHandler->Cancel();

  1027         }

  1028     

  1029     iSatCanceled = EFalse;

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

  1031     iShowDone = EFalse;

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

  1033     _DPRINT_FLAGS();

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

  1035     }

  1036 

  1037 // -----------------------------------------------------------------------------

  1038 // CPhSrvUssdManager::ShowDoneNoteL

  1039 //

  1040 // -----------------------------------------------------------------------------

  1041 //

  1042 void CPhSrvUssdManager::ShowDoneNoteL()

  1043     {

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

  1045     // Show global confirmation note "Done"

  1046     CHbDeviceMessageBoxSymbian::InformationL(

  1047         LoadDefaultString( KUssdDone ) );

  1048     iShowDone = EFalse;

  1049     }

  1050 

  1051 // -----------------------------------------------------------------------------

  1052 // CPhSrvUssdManager::ShowErrorNoteL

  1053 //

  1054 // -----------------------------------------------------------------------------

  1055 //

  1056 void CPhSrvUssdManager::ShowErrorNoteL( TInt aError )

  1057     {

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

  1059     if ( aError == KErrCancel )

  1060         {

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

  1062         return;

  1063         }

  1064 

  1065     // Show specific error message

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

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

  1068 

  1069     CHbDeviceMessageBoxSymbian::InformationL( buffer ->Des() );

  1070 

  1071     CleanupStack::PopAndDestroy( buffer ); 

  1072     CleanupStack::PopAndDestroy( textResolver ); 

  1073     

  1074     

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

  1076     return;

  1077     }

  1078 

  1079 

  1080 // -----------------------------------------------------------------------------

  1081 // CPhSrvUssdManager::DecodeL

  1082 //

  1083 // -----------------------------------------------------------------------------

  1084 //

  1085 void CPhSrvUssdManager::DecodeL(

  1086     const TDesC8& aSrc,

  1087     TDes& aDes ,

  1088     TUint8 aDcs )

  1089     {

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

  1091     aDes.Zero();

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

  1093 

  1094     iDCS = KPhCltDcsUnknown; // default

  1095 

  1096     // Check DCS

  1097     TSmsDataCodingScheme::TSmsAlphabet alphabet =

  1098         TSmsDataCodingScheme::ESmsAlphabet7Bit; // default

  1099     TUint cutChars = 0;

  1100     TUint startBit = 0;

  1101 

  1102     // Codes from GSM 03.38

  1103     if ( aDcs == KPhSrvUssdDcsAlphabetDefaultPrecededLanguage )

  1104         {

  1105         FindFirstCarriageReturnL( aSrc , cutChars , startBit );

  1106         }

  1107     else if ( aDcs == KPhSrvUssdDcsAlphabetUCS2PrecededLanguage )

  1108         {

  1109         alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;

  1110         cutChars = KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars;

  1111         }

  1112     else if ( (aDcs&KPhSrvUssdDcsGeneralInformationMask)  ==

  1113             KPhSrvUssdDcsGeneralInformation ) // General data coding information

  1114         {

  1115         //Is text compressed?

  1116         if ( aDcs & KPhSrvUssdDcsGeneralInformationCompressed )

  1117             {

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

  1119             User::Leave( KErrNotSupported );

  1120             }

  1121         // Is SIM specific message

  1122         else if ( ( aDcs & KPhSrvUssdDcsGeneralInformationSimMask )

  1123                    == KPhSrvUssdDcsGeneralInformationSim )

  1124             {

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

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

  1127             }

  1128         // 8 bit data?

  1129         else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==

  1130                    KPhSrvUssdDcsGeneralInformationAlphabet8Bit )

  1131             {

  1132             alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;

  1133             }

  1134         // UCS2 bit data?