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: 

    15 *    Implements the application UI and the methods derived from 

    16 *    MSatUiActionImplementer i.e. showing messages and asking input. 

    17 *

    18 *

    19 */

    20 

    21 

    22 // INCLUDE FILES

    23 #include    <barsread.h>

    24 #include    <badesca.h> // for descriptor arrays

    25 #include    <e32std.h>

    26 #include    <eikenv.h>

    27 #include    <eikapp.h>

    28 #include    <StringLoader.h>

    29 #include    <aknview.h>

    30 #include    <aknnotedialog.h>

    31 #include    <aknstaticnotedialog.h>

    32 #include    <AknGlobalNote.h>

    33 #include    <AknQueryDialog.h>

    34 #include    <aknmessagequerydialog.h>

    35 #include    <AudioPreference.h>

    36 #include    <mdaaudiotoneplayer.h>

    37 #include    <activitymanager.h>

    38 #include    <AknIconArray.h>

    39 #include    <AknPopupform.h>                //DisplayText icon popupform

    40 #include    <eikcapc.h>                     //CEikCaptionedControl

    41 #include    <txtrich.h>                     //CRichText

    42 #include    <eikrted.h>                     //CEikRichTextEditor

    43 #include    <hlplch.h>

    44 #include    <aknsoundsystem.h>

    45 #include    <AknWaitDialog.h>

    46 #include    <akntitle.h>

    47 #include    <AknUtils.h>

    48 #include    <AknIconUtils.h>

    49 #include    <aknconsts.h>

    50 #include    <avkon.hrh>

    51 #include    <SatUi.rsg>

    52 #include    <msatuiadapter.h>

    53 #include    <aknkeylock.h>

    54 

    55 #include    "satui.hrh"

    56 #include    "CSatUiApplication.h"

    57 #include    "CSatUiViewAppUi.h"

    58 #include    "CSatUiView.h"

    59 #include    "CSatUiTextQueryDialog.h"

    60 #include    "CSatUiMessageQueryIcon.h" 

    61 #include    "CSatUiWaitDialog.h"

    62 #include    "tflogger.h"

    63 

    64 #include    <MProfile.h>

    65 #include    <MProfileEngine.h>

    66 #include    <MProfileTones.h>

    67 #include    <TProfileToneSettings.h>

    68 #include    <MProfileName.h>

    69 #include    <MProfileExtraTones.h>

    70 #include    <featmgr.h>                     // Used for FeatureManager

    71 #include    <BTSapDomainPSKeys.h>           // For BT SAP connection state keys.

    72 #include    <e32property.h>                 // Used for RProperty

    73 #include    <aknnotewrappers.h>

    74 

    75 #include    <aknlayout.cdl.h> 

    76 #include    <aknlayoutscalable_avkon.cdl.h>

    77 #include    <ctsydomainpskeys.h>

    78 #include    <mda/common/resource.h>

    79 

    80 #include    <ProfileEngineSDKCRKeys.h>

    81 #include    <centralrepository.h>

    82 

    83 

    84 // CONSTANTS

    85 const TInt KSatActiveProfileOffline = 5; // value from ProfileEngine

    86 const TInt K32TIntMaxValue = 0x7FFFFFFF;

    87 // From UI spec 60 sec delay user response.

    88 const TInt KNoResponseFromUserDelay = 60; 

    89 const TInt KMicroSecondsInSecond = 1000000;

    90 const TInt KClearScreenDelay = 3;

    91 const TInt KMicroSecondsInTenthOfSecond = 100000;

    92 const TInt K3Seconds = 3000000;

    93 

    94 // Maximum length for sound file. 

    95 const TInt KMaxSoundFileLength = 256;

    96 // Audio sample is repeated indefinitely.

    97 const TInt KSoundPlayerRepeatForever = KMdaRepeatForever;

    98 // Used when dividing some values. Used only for preventing the use of magic 

    99 // numbers

   100 const TInt KDivideByEight = 8;

   101 

   102 const TUint8 KGetInputStringMaxSize = 0xEF;

   103 

   104 _LIT( K3Spaces, "   " );                    // Used for empty title.

   105 const TInt KEmptyTitleLength( 3 );          // Length of empty title.                      

   106 _LIT( KSatEmptySpace, " " );                // Used for empty item.

   107 _LIT( KSatEmptyDes, "" );

   108 

   109 const TUint8 KKeyZero = 0x30;

   110 const TUint8 KKeyNine = 0x39;

   111 const TUint8 KHwAsterisk = 0x2a;    // In hw scan code value for asterisk

   112 

   113 // The max volume value from settings.

   114 // From TProfileToneSettings.h

   115 const TInt KMaxVolumeFromProfile( 10 );

   116 

   117 // ================= MEMBER FUNCTIONS =======================

   118 

   119 // C++ default constructor can NOT contain any code, that

   120 // might leave.

   121 //

   122 CSatUiViewAppUi::CSatUiViewAppUi():

   123     iHelp( EFalse ),

   124     iSetUpMenuFirst( ETrue ),

   125     iSelectItemFirst( ETrue ),

   126     iPreviousForeground( EFalse ),

   127     iViewLoopCounter( 0 ),

   128     iDuration( TTimeIntervalMicroSeconds( static_cast<TInt64>( 0 ) ) ),

   129     iReqWSBufferID( KErrNone )

   130     {

   131     }

   132 

   133 // Symbian OS default constructor can leave.

   134 void CSatUiViewAppUi::ConstructL()

   135     {

   136     TFLOGSTRING( "CSatUiViewAppUi::ConstructL() called" )

   137     BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

   138     

   139     // Requests Window Server client buffer used by the application to

   140     // be of at least the given size.

   141     iReqWSBufferID = CAknEnv::Static()->RequestWsBuffer( KAknMaxWsBufferSize );

   142     TFLOGSTRING2( "iReqWSBufferID is %d", iReqWSBufferID )

   143 

   144     if ( BTSAPActivatedL() )

   145         {

   146         HBufC* sapText = 

   147             iCoeEnv->AllocReadResourceLC( R_QTN_OFFLINE_NOT_POSSIBLE_SAP );

   148         CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue );

   149         iForegroundControl = note;

   150         note->ExecuteLD( *sapText );

   151         iForegroundControl = NULL;

   152         CleanupStack::PopAndDestroy( sapText );

   153         Exit();

   154         }

   155 

   156     if ( ProfileState() == KSatActiveProfileOffline )

   157         {

   158         ShowNotAvailableNoteL();

   159         Exit();        

   160         }

   161 

   162     

   163     if ( StatusPane()->PaneCapabilities( TUid::Uid(

   164         EEikStatusPaneUidTitle ) ).IsPresent() )

   165         {

   166         CAknTitlePane* titlePane = STATIC_CAST( CAknTitlePane*,

   167             StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

   168         titlePane->SetTextL( KNullDesC );

   169         titlePane->DrawNow();

   170         }

   171         

   172     TFLOGSTRING( "CSatUiViewAppUi::ConstructL() exit" )

   173     }

   174 

   175 // Destructor.

   176 CSatUiViewAppUi::~CSatUiViewAppUi()

   177     {

   178     TFLOGSTRING( "CSatUiViewAppUi::~CSatUiViewAppUi() called" )

   179     this->StopShowWaitNote();

   180 

   181     delete iTitle;

   182     delete iAppName;

   183     delete iPlayer;

   184     delete iTimer;    

   185     

   186     TFLOGSTRING( "CSatUiViewAppUi::~CSatUiViewAppUi() exit" )

   187     }

   188 

   189 // ---------------------------------------------------------

   190 // CSatUiViewAppUi::CreateEmptyMenuL

   191 // Creates empty menu. This is used in SIM originated commands.

   192 // (other items were commented in a header).

   193 // ---------------------------------------------------------

   194 //

   195 void CSatUiViewAppUi::CreateEmptyMenuL()

   196     {

   197     TFLOGSTRING( "CSatUiViewAppUi::CreateEmptyMenuL() called" )

   198 

   199     // Create the menu item array with no content.

   200     CDesCArrayFlat* menuItems = new( ELeave ) CDesCArrayFlat( 1 );

   201     CleanupStack::PushL( menuItems );

   202     menuItems->Reset();

   203     menuItems->AppendL( KSatEmptySpace );

   204 

   205     // Create the empty next action indicator array.

   206     CArrayFixFlat<TSatAction>* menuActions =

   207         new( ELeave ) CArrayFixFlat<TSatAction>( 1 );

   208     CleanupStack::PushL( menuActions );

   209     menuActions->Reset();

   210 

   211     // Create empty title pane.

   212     HBufC* satTitle = HBufC::NewLC( KEmptyTitleLength );

   213     satTitle->Des().Append( K3Spaces );

   214 

   215     iSetUpMenuFirst = EFalse;

   216     iSetUpMenuView = CSatUiView::NewL( ETrue, this, ETrue );

   217     iSetUpMenuView->SetItemsL( satTitle, 

   218         *menuItems, 

   219         menuActions, 

   220         EFalse );

   221         

   222     // Hide list box.

   223     iSetUpMenuView->MakeListBoxVisible( EFalse );

   224     

   225     // Transfer ownership to CAknViewAppUi.

   226     AddViewL( iSetUpMenuView );

   227 

   228     iSetUpMenuView->SetAdapter( iAdapter );

   229     iActiveView = KSetUpMenuViewId; 

   230     

   231     // satTitle, menuActions, menuItems  

   232     CleanupStack::PopAndDestroy( satTitle );

   233     CleanupStack::PopAndDestroy( menuActions );

   234     CleanupStack::PopAndDestroy( menuItems );

   235     TFLOGSTRING( "CSatUiViewAppUi::CreateEmptyMenuL() exit" )

   236     }

   237 

   238 // ---------------------------------------------------------

   239 // CSatUiViewAppUi::SetAdapter

   240 // Sets the pointer to MSatUiAdapter object.

   241 // (other items were commented in a header).

   242 // ---------------------------------------------------------

   243 //

   244 void CSatUiViewAppUi::SetAdapter(

   245     MSatUiAdapter* aAdapter )

   246     {

   247     iAdapter = aAdapter;

   248     }

   249 

   250 // ---------------------------------------------------------

   251 // CSatUiViewAppUi::ShowWaitNoteL

   252 // Displays the wait note.

   253 // (other items were commented in a header).

   254 // ---------------------------------------------------------

   255 //

   256 void CSatUiViewAppUi::ShowWaitNoteL()

   257     {

   258     TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteL() called" )

   259     if ( !iWaitNote )

   260         {

   261         iWaitNote = new(ELeave)CAknWaitDialog(

   262             (REINTERPRET_CAST(CEikDialog**,&iWaitNote)));

   263         iForegroundControl = iWaitNote;

   264         iWaitNote->ExecuteLD( R_SATUI_WAIT_NOTE );

   265         // iForegroundControl won't be clear until the wait dialog

   266         // closed. It will avoid we lose the chance to set focus for

   267         // the wait dialog when the switch of foreground/background

   268         // happened.

   269         }

   270     TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteL() exit" )

   271     }

   272 

   273 // ---------------------------------------------------------

   274 // CSatUiViewAppUi::ShowWaitNoteWithoutDelayL

   275 // Displays the wait note without delay

   276 // (other items were commented in a header).

   277 // ---------------------------------------------------------

   278 //

   279 void CSatUiViewAppUi::ShowWaitNoteWithoutDelayL()

   280     {

   281     TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteWithoutDelayL() called" )

   282     if ( !iWaitNote )

   283         {

   284         iWaitNote = new(ELeave)CAknWaitDialog(

   285             (REINTERPRET_CAST(CEikDialog**,&iWaitNote)), ETrue );

   286         iForegroundControl = iWaitNote;

   287         iWaitNote->ExecuteLD( R_SATUI_WAIT_NOTE );

   288         // iForegroundControl won't be clear until the wait dialog

   289         // closed. It will avoid we lose the chance to set focus for

   290         // the wait dialog when the switch of foreground/background

   291         // happened.

   292         }

   293     TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteWithoutDelayL() exit" )

   294     }

   295 

   296 // ---------------------------------------------------------

   297 // CSatUiViewAppUi::StopShowWaitNote

   298 // Removes the wait note from the screen.

   299 // (other items were commented in a header).

   300 // ---------------------------------------------------------

   301 //

   302 void CSatUiViewAppUi::StopShowWaitNote()

   303     {

   304     TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() called" )

   305 

   306     if ( iNoteDialog )

   307         {

   308         iForegroundControl = NULL;

   309 

   310         TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing \

   311             NoteDialog" )

   312         delete iNoteDialog;

   313         iNoteDialog = NULL;

   314         }

   315 

   316     if ( iWaitNote )

   317         {

   318         iForegroundControl = NULL;

   319 

   320         TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing WaitNote" )

   321         // Process finished. The function was either ExecuteLD or RunLD.

   322         // This function call stops the execution of these function and 

   323         // causes the deletion of object

   324         TInt err(0);

   325         TRAP( err, iWaitNote->ProcessFinishedL() )

   326         TFLOGSTRING2(" 2nd: iWaitNote: %x ", iWaitNote )

   327         TFLOGSTRING2( "TRAP: %d", err )

   328         // Delete the object just in case. Seems that above method does not 

   329         // delete the object in some cases. e.g in very fast execution

   330         delete iWaitNote;

   331         iWaitNote = NULL;

   332         }

   333     if ( iBipWaitNote )

   334         {

   335         iForegroundControl = NULL;

   336 

   337         TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing BIP note" )

   338         delete iBipWaitNote;

   339         iBipWaitNote = NULL;

   340         }

   341         

   342     if ( iPermanentNote )

   343         {

   344         TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() \

   345                iPermanentNote cleared" )

   346         // If iPermanentNote exists until wait note is stopped,

   347         // then dialog has been already removed.

   348         iPermanentNote->ExitSleepingDialog();

   349         delete iPermanentNote;

   350         iPermanentNote = NULL;

   351         }

   352         

   353     TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() exit" )

   354     }

   355 

   356 // ---------------------------------------------------------

   357 // CSatUiViewAppUi::BTSAPActivatedL

   358 // Check that if BT SAP connection activated.

   359 // (other items were commented in a header).

   360 // ---------------------------------------------------------

   361 //

   362 TBool CSatUiViewAppUi::BTSAPActivatedL()

   363     {

   364 

   365     TFLOGSTRING( "CSatUiViewAppUi::BTSAPActivated() called" )

   366 

   367     TBool isActive( EFalse );

   368     FeatureManager::InitializeLibL();

   369     if ( FeatureManager::FeatureSupported( KFeatureIdBtSap ) )

   370         {

   371         TFLOGSTRING( "BTSAP is supported by ME" )

   372         TInt status( EBTSapNotConnected );

   373         TInt err = RProperty::Get( KPSUidBluetoothSapConnectionState, 

   374                                    KBTSapConnectionState, 

   375                                    status );

   376 

   377         if ( EBTSapNotConnected != status && !err )

   378             {

   379             TFLOGSTRING( "BTSAP is connected" )

   380             isActive = ETrue;

   381             }

   382         else

   383             {

   384             TFLOGSTRING3( "BTSAP status %d and error %d", status, err )

   385             }

   386         }

   387     else

   388         {

   389         TFLOGSTRING( "BTSAP is not supported by ME" )

   390         }

   391 

   392     FeatureManager::UnInitializeLib();

   393     TFLOGSTRING( "CSatUiViewAppUi::BTSAPActivated() exit" )

   394     return isActive;

   395 

   396     }

   397 

   398 // ---------------------------------------------------------

   399 // CSatUiViewAppUi::CoeEnv

   400 // Returns CoeEnv.

   401 // (other items were commented in a header).

   402 // ---------------------------------------------------------

   403 //

   404 CCoeEnv* CSatUiViewAppUi::CoeEnv()

   405     {

   406     return iCoeEnv;

   407     }

   408 

   409 // ---------------------------------------------------------

   410 // CSatUiViewAppUi::DisplayTextL

   411 // Displays the text in a note. 

   412 // (other items were commented in a header).

   413 // ---------------------------------------------------------

   414 //

   415 TSatUiResponse CSatUiViewAppUi::DisplayTextL(

   416     const TDesC& aText,

   417     const TDesC& aSimApplicationName,

   418     CFbsBitmap* aIconBitmapDisplayText,

   419     const TBool aSelfExplanatoryIcon,

   420     const TBool aSustainedText,

   421     const TTimeIntervalSeconds aDuration,

   422     const TBool aWaitUserToClear )

   423     {

   424     TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL called" )

   425     StopShowWaitNote();

   426 

   427     TSatUiResponse response( ESatSuccess );

   428     iHighPriorityEvent = EFalse;

   429     

   430     // Indication immediate response TLV for Display Text during MT call,

   431     // if it is immediate response, close dialog, otherwise leave it alone.

   432     iImmediateRsp = aSustainedText;

   433     TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL immediate rsp: %d", 

   434                    iImmediateRsp )    

   435     

   436     HBufC* header;

   437 

   438     if ( iHelp )

   439         {

   440         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL iHelp ETrue" )

   441         header = StringLoader::LoadLC(

   442             R_QTN_SAT_HELP_HEADER, iCoeEnv );

   443         iHelp = EFalse;

   444         }

   445     else

   446         {

   447         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL iHelp EFalse" )

   448         TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL length of \

   449             aSimApplicationName: %d", aSimApplicationName.Length() )

   450         if ( aSimApplicationName.Length() > 0 )

   451             {

   452             header = aSimApplicationName.AllocLC();

   453             }

   454         else

   455             {

   456             //Reads a resource string with memory allocation

   457             header = StringLoader::LoadLC( R_QTN_SAT_MESSAGE_HEADER, iCoeEnv );

   458             }

   459         }

   460 

   461     // Remove NULL characters from title

   462     RemoveNullCharacters( header );

   463 

   464     if ( aIconBitmapDisplayText )

   465         {

   466         //icon available use querydialog

   467         iDisplayTextIconDialog = CAknPopupForm::NewL();

   468         }

   469 

   470     CUserActivityManager* activityManager = 

   471         CUserActivityManager::NewL( EPriorityNormal );

   472 

   473     CleanupStack::PushL( activityManager );

   474     

   475     // Duration handling: 

   476     // If duration is given use that value for timeout.

   477     TTimeIntervalSeconds duration ( aDuration );

   478 

   479     // If user is expected to clear shown dialog and 

   480     // duration is NOT given use 60s timeout.

   481     if ( aWaitUserToClear && !aDuration.Int() )

   482         {

   483         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL wait user to clear" )

   484         duration = TTimeIntervalSeconds( KNoResponseFromUserDelay );

   485         }

   486     // If user is NOT expected to clear shown dialog and 

   487     // duration is NOT given use 3s timeout.

   488     else if ( !aDuration.Int() )

   489         {

   490         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL don't wait user \

   491             to clear" )

   492         duration = TTimeIntervalSeconds( KClearScreenDelay );

   493         }        

   494 

   495     // If not sustained or Clear after delay requested start timer

   496     if ( !aSustainedText || aDuration.Int() || !aWaitUserToClear )

   497         {

   498         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL No sustained text" )

   499         TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL duration: %d", 

   500             duration.Int() )

   501         

   502         // If duration is given start timer which doesn't 

   503         // care about user activity.        

   504         if ( aDuration.Int() )

   505             {

   506             CreateCallBackTimerL( duration.Int() * KMicroSecondsInSecond,

   507                 DelayCallback );

   508             }

   509         // Otherwise start timer which takes account user activity.

   510         else

   511             {

   512             User::ResetInactivityTime();

   513             activityManager->Start( duration, 

   514                 TCallBack( DispatchUserInactive, this ), 0 );            

   515             }

   516         }

   517 

   518     TInt userResponse;

   519 

   520     if ( aIconBitmapDisplayText )

   521         {

   522         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL have IconBitmap" )

   523         // Prepare dialog with icon

   524         iDisplayTextIconDialog->SetPopupFormType( EAknQuery );

   525         iDisplayTextIconDialog->PrepareLC( R_SATUI_MESSAGE_TEXT_ICON );

   526         iDisplayTextIconDialog->SetTitleL( *header );

   527 

   528         // Get richtext control

   529         CEikCaptionedControl* capControl = 

   530             iDisplayTextIconDialog->GetControlByControlType

   531             ( EEikCtRichTextEditor );

   532         CCoeControl* coeControl = NULL;

   533         if ( capControl )

   534             {

   535             coeControl = capControl->iControl;

   536             }

   537         if ( !coeControl )

   538             {

   539             User::Leave( KErrUnknown );

   540             }

   541         CEikRichTextEditor* rtxtEditor = 

   542             reinterpret_cast<CEikRichTextEditor*>( coeControl );

   543 

   544         if ( !aSelfExplanatoryIcon )

   545             {

   546             TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL not \

   547                 SelfExplanatoryIcon" )

   548             // Not selfexplanatory icon, add text

   549             // Get font

   550             const CFont* logicalFont = AknLayoutUtils::FontFromId( 

   551                 EAknLogicalFontSecondaryFont );

   552             

   553             // Extract font information

   554             TFontSpec fontspec = logicalFont->FontSpecInTwips();

   555             TCharFormat charFormat( fontspec.iTypeface.iName, 

   556                             fontspec.iHeight );

   557             

   558             // Make the font to be anti-aliased

   559             TFontStyle style;

   560             style.SetBitmapType( EAntiAliasedGlyphBitmap );

   561             charFormat.iFontSpec.iFontStyle = style;

   562                 

   563             // Set mask (which settings are set)

   564             TCharFormatMask charFormatMask;

   565             charFormatMask.SetAttrib( EAttColor );

   566             charFormatMask.SetAttrib( EAttFontTypeface );

   567             charFormatMask.SetAttrib( EAttFontHeight );

   568             

   569             // Apply settings

   570             rtxtEditor->RichText()->ApplyCharFormatL(

   571                 charFormat, charFormatMask, 0, 0 );

   572                     

   573             // One space between icon and text

   574             rtxtEditor->RichText()->InsertL( 0, KSatEmptySpace );

   575             rtxtEditor->RichText()->InsertL( 1, aText );

   576             }

   577 

   578         // Count icon size in twips 

   579         CWsScreenDevice* device = CCoeEnv::Static()->ScreenDevice();

   580         TInt width = device->HorizontalPixelsToTwips( 

   581             aIconBitmapDisplayText->SizeInPixels().iWidth );

   582         TInt height = device->VerticalPixelsToTwips( 

   583             aIconBitmapDisplayText->SizeInPixels().iHeight );

   584         TSize twipsSize( width, height );

   585 

   586         // Create picture

   587         CSatUiMessageQueryIcon* picture = new( ELeave ) 

   588             CSatUiMessageQueryIcon( twipsSize, *aIconBitmapDisplayText );

   589         TPictureHeader pictureHeader;    

   590         pictureHeader.iPicture = TSwizzle<CPicture>( picture );

   591         //Insert picture

   592         rtxtEditor->RichText()->InsertL( 0, pictureHeader );

   593         //Needed to show whole picture

   594         _LIT( KString, "\f\f\f");

   595         rtxtEditor->RichText()->InsertL( rtxtEditor->Text()->DocumentLength(),

   596             KString );

   597 

   598         // Set MSK same as LSK without any text causing the icon drawing

   599         iDisplayTextIconDialog->ButtonGroupContainer().SetCommandL(

   600             CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk,

   601             KSatEmptyDes );

   602         iForegroundControl = iDisplayTextIconDialog;

   603         userResponse = iDisplayTextIconDialog->RunLD();

   604         }

   605     else

   606         {

   607         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL don't have IconBitmap" )

   608         // Dialog without icon

   609         iDisplayTextDialog = new (ELeave) CAknMessageQueryDialog();

   610         iDisplayTextDialog->PrepareLC( R_SATUI_MESSAGE );

   611         iDisplayTextDialog->SetMessageTextL( aText );

   612         iDisplayTextDialog->QueryHeading()->SetTextL( *header );

   613 

   614         // Set MSK same as LSK without any text causing the icon drawing

   615         iDisplayTextDialog->ButtonGroupContainer().SetCommandL(

   616             CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk,

   617             KSatEmptyDes );

   618         iForegroundControl = iDisplayTextDialog;

   619         userResponse = iDisplayTextDialog->RunLD();

   620         }

   621     iForegroundControl = NULL;

   622 

   623     CleanupStack::PopAndDestroy( activityManager );

   624     CleanupStack::PopAndDestroy( header ); // header,activityManager

   625     // After duration call back timer is destroyed

   626     DestroyCallBackTimer();

   627     

   628     // If user is not expected to clear message used response is success

   629     // in timeout case.

   630     if ( userResponse 

   631         || ( iNoteClearedAfterDelay && !aWaitUserToClear ) )

   632         {

   633         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL successful response" )

   634         response = ESatSuccess;

   635         }

   636     else if ( iNoResponseFromUserAfterDelay || 

   637         ( aWaitUserToClear && iHighPriorityEvent ) )

   638         {

   639         TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL no user response" )

   640         // User did not close the text, closed by the timer or MT call

   641         response = ESatNoResponseFromUser;

   642         }

   643     else

   644         {

   645         if ( IsAppShutterRunning() )

   646             {

   647             TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL satsession \

   648                 terminated by user " )

   649             response = ESatSessionTerminatedByUser;

   650             iSessionTerminated = ETrue;

   651             }

   652         else

   653             {

   654             TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL backward \

   655                 requested by user " )

   656             response = ESatBackwardModeRequestedByUser;

   657             }

   658         }

   659 

   660     if ( iDisplayTextDialog )

   661         {

   662         iDisplayTextDialog = NULL;

   663         }

   664     if ( iDisplayTextIconDialog )

   665         {

   666         iDisplayTextIconDialog = NULL;

   667         }

   668 

   669     iNoteClearedAfterDelay = EFalse;

   670     iNoResponseFromUserAfterDelay = EFalse;

   671 

   672     ShowWaitNoteL();

   673         

   674     TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL exit, return: %d", response )

   675     return response;

   676     }

   677 

   678 // ---------------------------------------------------------

   679 // CSatUiViewAppUi::ClearScreen

   680 // Displays yes/no confirmation query.

   681 // (other items were commented in a header).

   682 // ---------------------------------------------------------

   683 //

   684 void CSatUiViewAppUi::ClearScreen()

   685     {

   686     TFLOGSTRING( "CSatUiViewAppUi::ClearScreen() called" )

   687     

   688     iNoteClearedAfterDelay = ETrue;

   689     CloseDialogs();

   690     

   691     TFLOGSTRING( "CSatUiViewAppUi::ClearScreen() exit" )

   692     }

   693 // ---------------------------------------------------------

   694 // CSatUiViewAppUi::GetYesNoL

   695 // Displays yes/no confirmation query.

   696 // (other items were commented in a header).

   697 // ---------------------------------------------------------

   698 //

   699 TSatUiResponse CSatUiViewAppUi::GetYesNoL(

   700     const TDesC& aText,

   701     const TSatCharacterSet aCharacterSet,

   702     TChar& aInkey,

   703     const CFbsBitmap* aIconBitmap,

   704     const TBool aSelfExplanatory,

   705     TUint& aDuration,

   706     const TBool aImmediateDigitResponse )

   707     {

   708     TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL called" )

   709     TSatUiResponse response( ESatSuccess );

   710 

   711     StopShowWaitNote();

   712 

   713     CUserActivityManager* activityManager = 

   714         CUserActivityManager::NewL( EPriorityNormal );

   715     CleanupStack::PushL( activityManager );

   716 

   717     // Start time for duration

   718     TTime startTime;

   719     iImmediateDigitResponse = aImmediateDigitResponse;

   720     

   721     TFLOGSTRING2( "CSatUiViewAppUi::GetYesNoL duration in 1/10 sec: %d",

   722             aDuration )

   723 

   724     // If duration is given use that value for timeout.

   725     // Start timer which doesn't care about user activity.

   726     if ( aDuration )

   727         {

   728         TInt duration ( 0 );

   729          

   730         TTimeIntervalMicroSeconds max32Bit(

   731             static_cast<TInt64>( K32TIntMaxValue ) );        

   732         TTimeIntervalMicroSeconds durationInTenthOfSeconds( 

   733             static_cast<TInt64>( aDuration ) );

   734         TTimeIntervalMicroSeconds durationInus( 

   735             durationInTenthOfSeconds.Int64() * KMicroSecondsInTenthOfSecond );

   736         

   737         if ( durationInus > max32Bit )

   738             {

   739             TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL durationInus bigger \

   740                 than max32Bit" )

   741             // since timers can only handle 32-bit values,

   742             // let's break the aDuration to smaller bits.

   743             // we break it here to 8 bits to fit in 32-bit value

   744             duration = durationInus.Int64() / KDivideByEight;

   745             iTimerRepeatOn = ETrue;

   746             }

   747         else

   748             {

   749             TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL durationInus less \

   750                 than max32Bit" )

   751             duration = durationInus.Int64();

   752             }

   753             

   754         CreateCallBackTimerL( duration, DelayCallback );

   755         startTime.HomeTime();

   756         }

   757     // Otherwise start timer which takes account user activity.

   758     else

   759         {

   760         User::ResetInactivityTime();

   761         activityManager->Start( 

   762             TTimeIntervalSeconds( KNoResponseFromUserDelay ),

   763             TCallBack( DispatchUserInactive, this ), 0 );            

   764         }

   765 

   766     TInt resource( 0 );        

   767 

   768     if ( aIconBitmap )

   769         {

   770         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL iGetYesNoIconDialog" )

   771 

   772         if ( ESatYesNo == aCharacterSet )

   773             {

   774             resource = R_SATUI_CONFIRM_YES_NO_QUERY_WITH_ICON;

   775             }

   776         else

   777             {

   778             resource = R_SATUI_IMMEDIATE_DIGIT_NOTE_WITH_ICON;

   779             }

   780         }

   781     else

   782         {

   783         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL iGetYesNoDialog" )

   784 

   785         if ( ESatYesNo == aCharacterSet )

   786             {

   787             resource = R_SATUI_CONFIRM_YES_NO_QUERY;

   788             }

   789         else

   790             {

   791             resource = R_SATUI_IMMEDIATE_DIGIT_QUERY;

   792             }

   793         }

   794     

   795     TInt userResponse = RunQueryDialogL( resource , aText, aIconBitmap,

   796         aSelfExplanatory, EAknSoftkeyYes );

   797 

   798     iImmediateDigitResponse = EFalse;

   799     

   800     // set received immediate digit response

   801     aInkey = iKey;

   802     iKey = 0;

   803     

   804     if ( aDuration )

   805         {

   806         TTime endTime;

   807         endTime.HomeTime();

   808         TTimeIntervalMicroSeconds timeDifference( 0 );

   809         timeDifference = endTime.MicroSecondsFrom( startTime );

   810         aDuration = timeDifference.Int64() / KMicroSecondsInTenthOfSecond;

   811         

   812         // After duration call back timer is destroyed

   813         DestroyCallBackTimer();

   814         }

   815     

   816     CleanupStack::PopAndDestroy( activityManager );

   817 

   818     // Timeout

   819     if ( iNoResponseFromUserAfterDelay )

   820         {

   821         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL no response from user" )

   822         response = ESatNoResponseFromUser;

   823         }

   824     // Cancel is pressed if immediate digit response without Yes/No

   825     else if ( !userResponse &&  ESatYesNo != aCharacterSet && !aInkey )

   826         {

   827         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL backward request by user" )

   828         response = ESatBackwardModeRequestedByUser;

   829         }

   830     // Yes button is used

   831     else if ( userResponse && !aInkey)

   832         {

   833         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL button used" )

   834         aInkey = 1;

   835         }

   836     // No button is used

   837     else if ( !aInkey )

   838         {

   839         TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL no button used" )

   840         aInkey = 0;

   841         }

   842 

   843     iNoResponseFromUserAfterDelay = EFalse;

   844 

   845     ShowWaitNoteL();

   846     

   847     TFLOGSTRING2( "CSatUiViewAppUi::GetYesNoL exit, return: %d", response )

   848     return response;

   849     }

   850 

   851 // ---------------------------------------------------------

   852 // CSatUiViewAppUi::GetInputL

   853 // Displays data query.

   854 // (other items were commented in a header).

   855 // ---------------------------------------------------------

   856 //

   857 TSatUiResponse CSatUiViewAppUi::GetInputL(

   858     const TDesC& aText,

   859     const TSatCharacterSet aCharacterSet,

   860     TDes& aInput,

   861     const TInt aMinLength,

   862     const TInt aMaxLength,

   863     const TBool aHideInput,

   864     const TBool aGetInkey,

   865     const CFbsBitmap* aIconBitmapGetInput,

   866     const TBool aSelfExplanatory,

   867     TUint& aDuration ) 

   868     {

   869     TFLOGSTRING( "CSatUiViewAppUi::GetInputL called" )

   870     StopShowWaitNote();

   871 

   872     TSatUiResponse response( ESatSuccess );

   873 

   874     TPtrC textPtr( aText );

   875 

   876     TInt minLength( 0 );

   877     TInt maxLength( 1 );

   878     

   879     TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aMinLength %d", aMinLength )

   880     TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aMaxLength %d", aMaxLength )

   881     //lint -e{961} else block not needed, minLength initialized.

   882     if ( aMinLength <= KGetInputStringMaxSize && aMinLength > 0 )

   883         {

   884         minLength = aMinLength;

   885         }

   886     else if ( aMinLength > KGetInputStringMaxSize )

   887         {

   888         minLength = KGetInputStringMaxSize;

   889         }

   890 

   891     //lint -e{961} else block not needed, maxLength initialized.

   892     if ( aMaxLength < minLength )

   893         {

   894         maxLength = minLength;

   895         }

   896     else if ( aMaxLength <= KGetInputStringMaxSize && aMaxLength > 1 )

   897         {

   898         maxLength = aMaxLength;

   899         }

   900     else if ( aMaxLength > KGetInputStringMaxSize )

   901         {

   902         maxLength = KGetInputStringMaxSize;

   903         }

   904 

   905     HBufC* input = HBufC::NewLC( KGetInputStringMaxSize );

   906     TPtr inputPtr(input->Des());

   907 

   908     HBufC* textHolder = NULL;

   909     

   910     TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aInput.Length %d",\

   911         aInput.Length() )

   912 

   913     if ( ( aInput.Length() >= minLength )

   914         && ( aInput.Length() <= maxLength ) )

   915         {

   916         inputPtr = aInput;

   917         }

   918 

   919     TInt userResponse;

   920 

   921     CUserActivityManager* activityManager = 

   922         CUserActivityManager::NewL( EPriorityNormal );

   923 

   924     CleanupStack::PushL( activityManager );

   925 

   926     // Start time for timer

   927     TTime startTime;

   928 

   929     // If duration is given use that value for timeout.

   930     // Start timer which doesn't care about user activity.

   931     if ( aDuration && aGetInkey )

   932         {

   933         TFLOGSTRING2( "CSatUiViewAppUi::GetInputL duration in 1/10 sec: %d",

   934             aDuration )        

   935         

   936         TInt duration ( 0 );

   937          

   938         TTimeIntervalMicroSeconds max32Bit(

   939             static_cast<TInt64>( K32TIntMaxValue ) );        

   940         TTimeIntervalMicroSeconds durationInTenthOfSeconds( 

   941             static_cast<TInt64>( aDuration ) );

   942         TTimeIntervalMicroSeconds durationInus( 

   943             durationInTenthOfSeconds.Int64() * KMicroSecondsInTenthOfSecond );

   944         

   945         if ( durationInus > max32Bit )

   946             {

   947             TFLOGSTRING( "CSatUiViewAppUi::GetInputL durationInus bigger \

   948                 than max32Bit" )

   949             // since timers can only handle 32-bit values,

   950             // let's break the aDuration to smaller bits.

   951             // we break it here to 8 bits to fit in 32-bit value

   952             duration = durationInus.Int64() / KDivideByEight;

   953             iTimerRepeatOn = ETrue;

   954             }

   955         else

   956             {

   957             TFLOGSTRING( "CSatUiViewAppUi::GetInputL durationInus less \

   958                 than max32Bit" )

   959             duration = durationInus.Int64();

   960             }

   961             

   962         CreateCallBackTimerL( duration, DelayCallback );

   963         startTime.HomeTime();

   964         }

   965     // Otherwise start timer which takes account user activity.

   966     else

   967         {

   968         User::ResetInactivityTime();

   969         activityManager->Start( 

   970             TTimeIntervalSeconds( KNoResponseFromUserDelay ),

   971             TCallBack( DispatchUserInactive, this ), 0 );            

   972         }

   973 

   974     CEikImage* image = new(ELeave) CEikImage;

   975     CleanupStack::PushL( image );

   976     

   977     if ( aIconBitmapGetInput )

   978         {        

   979         image->SetBitmap( aIconBitmapGetInput );

   980     

   981         // Create mask for icon bitmap

   982         CFbsBitmap* mask = new(ELeave) CFbsBitmap;

   983 

   984         TSize size = aIconBitmapGetInput->SizeInPixels();

   985         CleanupStack::PushL( mask );

   986         MakeGetInputBitmapMask( mask, size );

   987 

   988         image->SetMask( mask );

   989         CleanupStack::Pop( mask ); 

   990         }

   991 

   992     TInt resource( 0 );

   993     TInt textResource( 0 );

   994     // Query dialog

   995     iGetInputDialog = new (ELeave) CSatUiTextQueryDialog( inputPtr,

   996                 CAknQueryDialog::ENoTone, minLength, maxLength );

   997     iForegroundControl = iGetInputDialog;

   998 

   999     if ( aCharacterSet == ESatDigitOnly ) 

  1000         {

  1001         TFLOGSTRING( "CSatUiViewAppUi::GetInputL ESatDigitOnly" )

  1002         if ( aText.Length() == 0 )

  1003             {

  1004             if ( aGetInkey )

  1005                 {

  1006                 textResource = R_TEXT_SIMATK_ENTER_NBR;

  1007                 }

  1008             else

  1009                 {

  1010                 textResource = R_TEXT_SIMATK_ENTER_NBR_STRING;

  1011                 }

  1012             }

  1013         

  1014         // Hidden digit as input

  1015         if ( aHideInput )

  1016             {            

  1017             TFLOGSTRING( "CSatUiViewAppUi::GetInputL Hidden digit" )            

  1018             if ( aIconBitmapGetInput )

  1019                 {

  1020                 resource = R_SATUI_HIDDEN_NUMBER_QUERY_WITH_LABEL_AND_ICON;

  1021                 }

  1022             else

  1023                 {

  1024                 resource = R_SATUI_HIDDEN_NUMBER_QUERY_WITHOUT_LABEL;

  1025                 }

  1026             }

  1027         // Normal number query

  1028         else

  1029             {

  1030             TFLOGSTRING( "CSatUiViewAppUi::GetInputL normal digit" ) 

  1031             if ( aIconBitmapGetInput )

  1032                 {

  1033                 resource = R_SATUI_NUMBER_QUERY_WITH_LABEL_AND_ICON;

  1034                 }

  1035             else

  1036                 {

  1037                 resource = R_SATUI_NUMBER_QUERY_WITHOUT_LABEL;

  1038                 }

  1039             }

  1040         }

  1041 

  1042     else // ESatCharSmsDefaultAlphabet or ESatCharUcs2Alphabet

  1043         {

  1044         TFLOGSTRING( "CSatUiViewAppUi::GetInputL ESatCharSmsDefaultAlphabet \

  1045             or ESatCharUcs2Alphabet" )

  1046         if ( aText.Length() == 0 )

  1047             {

  1048             if ( aGetInkey )

  1049                 {

  1050                 textResource = R_TEXT_SIMATK_ENTER_CHAR;

  1051                 }

  1052             else

  1053                 {

  1054                 textResource = R_TEXT_SIMATK_ENTER_CHAR_STRING;

  1055                 }

  1056             }

  1057         

  1058         if ( !aGetInkey )

  1059             {

  1060             iGetInputDialog->SetPredictiveTextInputPermitted( ETrue );

  1061             }

  1062 

  1063         iGetInputDialog->SetMaxLength( maxLength );

  1064 

  1065         if ( aIconBitmapGetInput )

  1066             {

  1067             resource = R_SATUI_TEXT_QUERY_WITH_LABEL_AND_ICON;

  1068             }

  1069         else

  1070             {

  1071             resource = R_SATUI_TEXT_QUERY_WITHOUT_LABEL;

  1072             }

  1073         }

  1074 

  1075     // Read default text if sim doesn't provide text to dialog 

  1076     if ( aText.Length() == 0 )

  1077         {

  1078         // Reads a resource string with memory allocation

  1079         // and pushes the string onto the cleanup stack.

  1080         textHolder = StringLoader::LoadLC( textResource, iCoeEnv);

  1081         textPtr.Set( *textHolder );       

  1082         }

  1083 

  1084     // Icon is used and command is get input

  1085     if ( aIconBitmapGetInput )

  1086         {

  1087         TFLOGSTRING( "CSatUiViewAppUi::GetInputL icon is used" )

  1088         iGetInputDialog->PrepareLC( resource );

  1089         if ( !aSelfExplanatory )

  1090             {

  1091             // Icon is not self-explanatory, show also text

  1092             iGetInputDialog->SetPromptL( textPtr );            

  1093             }

  1094         // Add icon to query

  1095         iGetInputDialog->QueryHeading()->SetHeaderImageL( image );

  1096         // Set MSK same as LSK without any text causing the icon drawing

  1097         iGetInputDialog->ButtonGroupContainer().SetCommandL(

  1098             CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk,

  1099             KSatEmptyDes );

  1100         userResponse = iGetInputDialog->RunLD();

  1101         TFLOGSTRING2( "CSatUiViewAppUi::GetInputL userResponse is: %d",

  1102             userResponse )                

  1103         }

  1104     // No icon in use

  1105     else

  1106         {

  1107         TFLOGSTRING( "CSatUiViewAppUi::GetInputL icon isn't used" )

  1108         iGetInputDialog->PrepareLC( resource );

  1109         iGetInputDialog->SetPromptL( textPtr );  

  1110         // Set MSK same as LSK without any text causing the icon drawing

  1111         iGetInputDialog->ButtonGroupContainer().SetCommandL(

  1112             CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk,

  1113             KSatEmptyDes );

  1114         userResponse = iGetInputDialog->RunLD();

  1115         TFLOGSTRING2( "CSatUiViewAppUi::GetInputL userResponse is: %d",

  1116             userResponse )                

  1117         }

  1118     iForegroundControl = NULL;

  1119 

  1120     if ( textHolder )

  1121         {

  1122         CleanupStack::PopAndDestroy( textHolder ); 

  1123         }

  1124 

  1125     if ( aDuration && aGetInkey )

  1126         {

  1127         TTime endTime;

  1128         endTime.HomeTime();

  1129         TTimeIntervalMicroSeconds timeDifference( 0 );

  1130         timeDifference = endTime.MicroSecondsFrom( startTime );

  1131         aDuration = timeDifference.Int64() / KMicroSecondsInTenthOfSecond;

  1132         

  1133         // After duration call back timer is destroyed

  1134         DestroyCallBackTimer();