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      iTextResolver ( EFalse ),

   394      iTextBuffer ( NULL )

   395     {

   396     CActiveScheduler::Add( this );

   397     }

   398 

   399 

   400 // -----------------------------------------------------------------------------

   401 // CPhSrvUssdManager::~CPhSrvUssdManager

   402 //

   403 // Destructor

   404 //

   405 // -----------------------------------------------------------------------------

   406 //

   407 CPhSrvUssdManager::~CPhSrvUssdManager()

   408     {

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

   410 

   411 

   412     delete iUssdSendHandler;

   413     iUssdSendHandler = NULL;

   414 

   415     delete iUssdReceiveHandler;

   416     iUssdReceiveHandler = NULL;

   417 

   418     delete iUssdNotifyNWRelease;

   419     iUssdNotifyNWRelease = NULL;

   420 

   421     Cancel();

   422 

   423     iTimer.Close();

   424     

   425     delete iTextBuffer;

   426     iTextBuffer = NULL;

   427     

   428     delete iDeviceDialog;

   429     iDeviceDialog = NULL;

   430 

   431     if ( iNotifyArray )

   432         {

   433         iNotifyArray->Reset();

   434         }

   435     delete iNotifyArray;

   436     if ( iUssdReplyTimer )

   437         {

   438         iUssdReplyTimer->Stop();

   439         }

   440     delete iUssdReplyTimer;

   441     iUssdReplyTimer = NULL;

   442 

   443     iFsSession.Close();

   444 

   445     iMobileUssdMessaging.Close();

   446     

   447     delete iMoAckCallback;

   448 

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

   450     }

   451 

   452 

   453 // -----------------------------------------------------------------------------

   454 // CPhSrvUssdManager::ConstructL

   455 //

   456 // Symbian OS 2nd phase constructor

   457 //

   458 // -----------------------------------------------------------------------------

   459 //

   460 void CPhSrvUssdManager::ConstructL( MPhSrvPhoneInterface& aPhoneInterface )

   461     {

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

   463     iTextResolver = HbTextResolverSymbian::Init( 

   464         KUssdLocFilename, KLocPath );

   465     _DDPRINT( 4, "PhSrv.ConstructL.ussd loc:", iTextResolver );

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

   467 

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

   469 

   470     // Check support

   471     RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   472     RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

   474 

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

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

   477         {

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

   479         iUssdReceiveHandler = new( ELeave ) CPhSrvUssdReceiveHandler(

   480             *this,

   481             iMobileUssdMessaging );

   482         iUssdReceiveHandler->ConstructL();

   483 

   484         iUssdNotifyNWRelease = new( ELeave )  CPhSrvUssdNotifyNWRelease(

   485             *this,

   486             iMobileUssdMessaging );

   487 

   488         iUssdNotifyNWRelease->ConstructL();

   489         }

   490 

   491     iPhoneInterface = &aPhoneInterface;

   492 

   493     SendHandlerL();

   494     

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

   496 

   497     iVariantReadOnlyValues = KPhSrvDefaultValue;

   498 

   499     User::LeaveIfError( GetTelephonyVariantData() );

   500 

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

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

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

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

   505     }

   506 

   507 

   508 // -----------------------------------------------------------------------------

   509 // CPhSrvUssdManager::SendHandlerL

   510 //

   511 // The send handler.

   512 //

   513 // -----------------------------------------------------------------------------

   514 //

   515 CPhSrvUssdSendHandler& CPhSrvUssdManager::SendHandlerL()

   516     {

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

   518     // is supported by the TSY.

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

   520     if ( iUssdSendHandler == NULL )

   521         {

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

   523         RMobileUssdMessaging::TMobileUssdCapsV1 caps;

   524         RMobileUssdMessaging::TMobileUssdCapsV1Pckg pckgCaps( caps );

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

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

   527 

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

   529             ( caps.iUssdFormat & RMobileUssdMessaging::KCapsPackedString )

   530             == 0 )

   531             {

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

   533             User::Leave( KErrNotSupported );

   534             }

   535 

   536         iUssdSendHandler =

   537             new( ELeave ) CPhSrvUssdSendHandler(

   538                 *this,

   539                 iMobileUssdMessaging,

   540                 *iPhoneInterface );

   541         }

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

   543     return *iUssdSendHandler;

   544     }

   545 

   546 

   547 // -----------------------------------------------------------------------------

   548 // CPhSrvUssdManager::SendUssdL

   549 //

   550 // Send the USSD message.

   551 //

   552 // -----------------------------------------------------------------------------

   553 //

   554 void CPhSrvUssdManager::SendUssdL(

   555     const TDesC8& aMsgData,

   556     RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttribute,

   557     MPhSrvUssdMessageSentObserver& aObserver )

   558     {

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

   560     _DPRINT_FLAGS();

   561     

   562     if ( iObserver && iNetworkReleased ) 

   563         {

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

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

   566         // and clean up the pointer.

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

   568         if ( iUssdSendHandler ) 

   569             {

   570             iUssdSendHandler->Cancel();

   571             }

   572         iObserver->UssdMessageSentObserverHandleResult( KErrSessionClosed );

   573         iObserver = NULL;

   574         }

   575     

   576     if ( iObserver || iSendingAck )

   577         {

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

   579         // Other client is using the service.

   580         User::Leave( KErrInUse );

   581         }

   582 

   583     // Check that message type is set

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

   585         == 0 )

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

   587         {

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

   589         aMsgAttribute.iFlags |= RMobileUssdMessaging::KUssdMessageType;

   590         if ( NetworkWaitingForAnAnswer() )

   591             {

   592             // Network is waiting for an answer

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

   594             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMOReply;

   595             }

   596         else

   597             {

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

   599             aMsgAttribute.iType = RMobileUssdMessaging::EUssdMORequest;

   600             }

   601         }

   602         

   603     RMobileUssdMessaging::TMobileUssdAttributesV1Pckg attribs( aMsgAttribute );

   604     iShowDone = ETrue;

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

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

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

   608     iObserver = &aObserver;

   609     // Not closing nor closed anymore

   610     iNetworkReleased = EFalse;

   611     iSendRelease = EFalse;

   612     iClearArray = EFalse;

   613     

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

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

   616     if ( NetworkWaitingForAnAnswer() )

   617         {

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

   619         iUssdReplyTimer->Stop();

   620         }

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

   622     }

   623 

   624 // -----------------------------------------------------------------------------

   625 // CPhSrvUssdManager::NetworkWaitingForAnAnswer

   626 // -----------------------------------------------------------------------------

   627 //

   628 TBool CPhSrvUssdManager::NetworkWaitingForAnAnswer() 

   629     {

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

   631     }

   632 // -----------------------------------------------------------------------------

   633 // CPhSrvUssdManager::SendUssdCancel

   634 //

   635 // Cancel the USSD sending.

   636 //

   637 // -----------------------------------------------------------------------------

   638 //

   639 void CPhSrvUssdManager::SendUssdCancel()

   640     {

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

   642 

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

   644     // the whole session

   645     _DPRINT_FLAGS();

   646     if ( !iSendingAck || iSendRelease ) 

   647         {

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

   649         iUssdSendHandler->SendUssdCancel();

   650         }

   651 

   652     if ( iHavePendingSatMessagePointer )

   653         {

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

   655         iSatCanceled = ETrue;

   656         }

   657     iObserver = NULL;

   658     

   659     SetActiveIfPendingNotificationsExist();

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

   661     }

   662 

   663 // -----------------------------------------------------------------------------

   664 // CPhSrvUssdManager::SetActiveIfPendingNotificationsExist

   665 // -----------------------------------------------------------------------------

   666 //

   667 void CPhSrvUssdManager::SetActiveIfPendingNotificationsExist()

   668     {

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

   670         {

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

   672         iLaunchGMQ = ETrue;

   673         iNotifyMessage = ETrue;

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

   675         iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   676         SetActive();

   677         _DPRINT_FLAGS();

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

   679         }

   680     }

   681 // -----------------------------------------------------------------------------

   682 // CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL

   683 //

   684 //

   685 //

   686 // -----------------------------------------------------------------------------

   687 //

   688 void CPhSrvUssdManager::UssdNetworkObserverHandleSendEventL( TInt aError )

   689     {

   690     // debug print

   691     _DDPRINT(

   692         4,

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

   694         aError );

   695 

   696     // complete SAT if needed

   697     if ( aError < KErrNone )

   698         {

   699  

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

   701         CompleteSatL( NULL, aError );

   702         }

   703 

   704     if ( iObserver )

   705         {

   706  

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

   708 

   709         iObserver->UssdMessageSentObserverHandleResult( aError );

   710         iObserver = NULL;

   711         }

   712     

   713     iSendingAck = EFalse;

   714     

   715     AsyncProcessMoAcks();

   716     

   717     // debug print

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

   719     }

   720 

   721 

   722 // -----------------------------------------------------------------------------

   723 // CPhSrvUssdManager::UssdAppTaskExists

   724 //

   725 //

   726 //

   727 // -----------------------------------------------------------------------------

   728 //

   729 TBool CPhSrvUssdManager::UssdAppTaskExistsL()

   730 {   

   731     TBool ret = EFalse;

   732     RWsSession wsSession;

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

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

   735     CleanupClosePushL(wsSession);

   736     TApaTaskList tasklist(wsSession);

   737     TApaTask task = tasklist.FindApp( KUssdSecureId );

   738     ret = task.Exists();

   739 

   740     CleanupStack::PopAndDestroy();

   741     return ret;

   742 }

   743 

   744 // -----------------------------------------------------------------------------

   745 // CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL

   746 //

   747 //

   748 //

   749 // -----------------------------------------------------------------------------

   750 //

   751 void CPhSrvUssdManager::UssdNetworkObserverHandleReceivedEventL(

   752     const TDes8& aMsgData,

   753     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes,

   754     TInt aError )

   755     {

   756     _DDPRINT(

   757         4,

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

   759         aError );

   760     _DPRINT_FLAGS();

   761     if ( aError != KErrNone )

   762         {

   763         TurnLightsOn(); //Ensure lights on

   764  

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

   766         ShowErrorNoteL( aError );

   767         }

   768     else if ( iSendRelease )

   769         {

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

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

   772         }

   773     else

   774         {

   775         UssdHandleReceivedEventL( aMsgData, aMsgAttributes );

   776         }

   777     }

   778 

   779 // -----------------------------------------------------------------------------

   780 // CPhSrvUssdManager::UssdHandleReceivedEventL

   781 // -----------------------------------------------------------------------------

   782 //

   783 void CPhSrvUssdManager::UssdHandleReceivedEventL(

   784     const TDes8& aMsgData,

   785     const RMobileUssdMessaging::TMobileUssdAttributesV1& aMsgAttributes )

   786     {

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

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

   789     iNetworkReleased = EFalse;

   790         

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

   792     if ( iObserver )

   793         {

   794  

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

   796         UssdNetworkObserverHandleSendEventL( 1 ); // some positive value

   797         }

   798     

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

   800          aMsgAttributes.iType == RMobileUssdMessaging::EUssdMTRequest )

   801         {

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

   803         RestartReplyTimerL();

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

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

   806         }

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

   808     TUint8 dcs = KPhSrvUssdDefaultDCS;

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

   810         {

   811         dcs = aMsgAttributes.iDcs;

   812         }

   813     iDecodedMessage.Zero();

   814     iReceivedMessage.Zero();

   815     DecodeL(aMsgData, iDecodedMessage, dcs);

   816     if(iDecodedMessage.Length() > 0)

   817         {

   818         iReceivedMessage = iDecodedMessage;

   819         }

   820     // 5. Show note.

   821     // debug print

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

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

   824             aMsgAttributes.iType != RMobileUssdMessaging::EUssdMTRequest )

   825         {

   826         if ( !ShowNotesL() )

   827             {

   828      

   829             _DPRINT( 4,

   830                 "PhSrv.UssdHandleReceivedEventL.SAtReturn" );

   831             return;

   832             }

   833         }

   834 

   835     // empty string is handled as ok message

   836     if ( !iDecodedMessage.Length() )

   837         {

   838         TurnLightsOn(); //Ensure lights on

   839  

   840         _DPRINT( 4,

   841             "PhSrv.UssdHandleReceivedEventL.EmptyString" );

   842         

   843         ShowDoneNoteL();

   844 

   845  

   846         _DPRINT( 4,

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

   848         }

   849     else

   850         {

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

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

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

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

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

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

   857         

   858         if ( iNotifyMessage ) 

   859             {

   860             // need to send an MO ack

   861             iAcksToBeSent ++;

   862             }

   863         

   864         if ( !iDeviceDialog  ){

   865             iDeviceDialog = CHbDeviceMessageBoxSymbian::NewL(

   866                 CHbDeviceMessageBoxSymbian::EInformation );

   867             iDeviceDialog->SetObserver( this );

   868             iDeviceDialog->SetTimeout( KPhSrvUssdTimeout );

   869             iDeviceDialog->SetDismissPolicy ( KPhSrvUssdPopupDismissPolicy );

   870             

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

   872             iDeviceDialog->SetButton( 

   873                 CHbDeviceMessageBoxSymbian::EAcceptButton, EFalse );

   874             // Show Exit Key always

   875             iDeviceDialog->SetButton( 

   876                 CHbDeviceMessageBoxSymbian::ERejectButton, ETrue );

   877             iDeviceDialog->SetButtonTextL(

   878                 CHbDeviceMessageBoxSymbian::ERejectButton, 

   879                 LoadDefaultString( KUssdExit ) );

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

   881         }

   882       

   883         if ( iNotifyMessage || iMsgTypeReply )

   884             {

   885             //This is for reply message in notifyarray

   886             iNotifyMessage = ETrue;

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

   888 

   889             //Notify added to array

   890             iNotifyArray->AppendL( iReceivedMessage );

   891 

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

   893             UpdateNotifyMessageL();

   894 

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

   896                 {

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

   898                 Cancel();

   899                 }

   900             }

   901         else

   902             {

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

   904             Cancel();

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

   906             }

   907 

   908         // Remove Reply key

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

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

   911             {

   912             // Remove Answer key

   913             iDeviceDialog->SetButton( 

   914                 CHbDeviceMessageBoxSymbian::EAcceptButton, EFalse );

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

   916             }

   917         // Show Reply key

   918         else

   919             {

   920             iDeviceDialog->SetButton( 

   921                 CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue );              

   922             iDeviceDialog->SetButtonTextL(

   923                 CHbDeviceMessageBoxSymbian::EAcceptButton, 

   924                 LoadDefaultString( KUssdReply ) ); 

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

   926             }

   927 

   928  

   929         _DPRINT( 4,

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

   931 

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

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

   934         // <-- QT PHONE START-->

   935         /*

   936         if ( IsTelephonyFeatureSupported( KTelephonyLVFlagUssdTone ) )

   937             {

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

   939             PlayUssdTone();

   940             }

   941         */

   942             // <-- QT PHONE END-->

   943         // Launch the new message query

   944         if ( !IsActive() )

   945             {

   946             iLaunchGMQ = ETrue;

   947             iTimer.After( iStatus , KPhSrvUssdMessageQueryInterval );

   948             SetActive();

   949             }

   950         AsyncProcessMoAcks();

   951         }

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

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

   954         {

   955         iEmptyEditor = ETrue;

   956         }

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

   958     }

   959 

   960 // -----------------------------------------------------------------------------

   961 // CPhSrvUssdManager::RestartReplyTimerL

   962 //

   963 //

   964 //

   965 // -----------------------------------------------------------------------------

   966 //

   967 void CPhSrvUssdManager::RestartReplyTimerL()

   968     {

   969     if ( iUssdReplyTimer )

   970         {

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

   972         iUssdReplyTimer->Stop();

   973         }

   974 

   975     if ( !iUssdReplyTimer )

   976         {

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

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

   979         }

   980     

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

   982     iUssdReplyTimer->Start();

   983     }

   984 

   985 // -----------------------------------------------------------------------------

   986 // CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL

   987 //

   988 //

   989 //

   990 // -----------------------------------------------------------------------------

   991 //

   992 void CPhSrvUssdManager::UssdNetworkObserverHandleNotifyNWReleaseL(

   993 const RMobilePhone::TMobilePhoneSendSSRequestV3 & aReturnResult,

   994 TInt aError )

   995     {

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

   997     _DPRINT_FLAGS();

   998     TBool showNotes = ShowNotesL();

   999     iNetworkReleased = ETrue;

  1000     iSendingAck = EFalse;

  1001     iSendRelease = EFalse;

  1002     iAcksToBeSent = 0;

  1003     

  1004     if ( iHavePendingSatMessagePointer )

  1005         {

  1006         iReturnResult = aReturnResult;

  1007         if ( !iSatCanceled )

  1008             {

  1009             CompleteSatL(&iReceivedMessage, aError );

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

  1011             }

  1012         }

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

  1014         {

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

  1016         iUssdReplyTimer->Stop();

  1017         Cancel();

  1018         CheckArray();

  1019         }

  1020     if ( showNotes && iShowDone )

  1021         {

  1022         ShowDoneNoteL();

  1023         }

  1024     if ( iUssdSendHandler && iSendingAck ) 

  1025         {

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

  1027         iUssdSendHandler->Cancel();

  1028         }

  1029     

  1030     iSatCanceled = EFalse;

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

  1032     iShowDone = EFalse;

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

  1034     _DPRINT_FLAGS();

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

  1036     }

  1037 

  1038 // -----------------------------------------------------------------------------

  1039 // CPhSrvUssdManager::ShowDoneNoteL

  1040 //

  1041 // -----------------------------------------------------------------------------

  1042 //

  1043 void CPhSrvUssdManager::ShowDoneNoteL()

  1044     {

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

  1046     // Show global confirmation note "Done"

  1047     CHbDeviceMessageBoxSymbian::InformationL(

  1048         LoadDefaultString( KUssdDone ) );

  1049     iShowDone = EFalse;

  1050     }

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // CPhSrvUssdManager::ShowErrorNoteL

  1054 //

  1055 // -----------------------------------------------------------------------------

  1056 //

  1057 void CPhSrvUssdManager::ShowErrorNoteL( TInt aError )

  1058     {

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

  1060     if ( aError == KErrCancel )

  1061         {

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

  1063         return;

  1064         }

  1065 

  1066     // Show specific error message

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

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

  1069 

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

  1071 

  1072     CleanupStack::PopAndDestroy( buffer ); 

  1073     CleanupStack::PopAndDestroy( textResolver ); 

  1074     

  1075     

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

  1077     return;

  1078     }

  1079 

  1080 

  1081 // -----------------------------------------------------------------------------

  1082 // CPhSrvUssdManager::DecodeL

  1083 //

  1084 // -----------------------------------------------------------------------------

  1085 //

  1086 void CPhSrvUssdManager::DecodeL(

  1087     const TDesC8& aSrc,

  1088     TDes& aDes ,

  1089     TUint8 aDcs )

  1090     {

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

  1092     aDes.Zero();

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

  1094 

  1095     iDCS = KPhCltDcsUnknown; // default

  1096 

  1097     // Check DCS

  1098     TSmsDataCodingScheme::TSmsAlphabet alphabet =

  1099         TSmsDataCodingScheme::ESmsAlphabet7Bit; // default

  1100     TUint cutChars = 0;

  1101     TUint startBit = 0;

  1102 

  1103     // Codes from GSM 03.38

  1104     if ( aDcs == KPhSrvUssdDcsAlphabetDefaultPrecededLanguage )

  1105         {

  1106         FindFirstCarriageReturnL( aSrc , cutChars , startBit );

  1107         }

  1108     else if ( aDcs == KPhSrvUssdDcsAlphabetUCS2PrecededLanguage )

  1109         {

  1110         alphabet = TSmsDataCodingScheme::ESmsAlphabetUCS2;

  1111         cutChars = KPhSrvUssdDcsAlphabetUCS2PrecededLanguageSkipChars;

  1112         }

  1113     else if ( (aDcs&KPhSrvUssdDcsGeneralInformationMask)  ==

  1114             KPhSrvUssdDcsGeneralInformation ) // General data coding information

  1115         {

  1116         //Is text compressed?

  1117         if ( aDcs & KPhSrvUssdDcsGeneralInformationCompressed )

  1118             {

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

  1120             User::Leave( KErrNotSupported );

  1121             }

  1122         // Is SIM specific message

  1123         else if ( ( aDcs & KPhSrvUssdDcsGeneralInformationSimMask )

  1124                    == KPhSrvUssdDcsGeneralInformationSim )

  1125             {

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

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

  1128             }

  1129         // 8 bit data?

  1130         else if ( ( aDcs&KPhSrvUssdDcsGeneralInformationAlphabetMask ) ==

  1131                    KPhSrvUssdDcsGeneralInformationAlphabet8Bit )

  1132             {

  1133             alphabet = TSmsDataCodingScheme::ESmsAlphabet8Bit;

  1134             }