1 /*

     2 * Copyright (c) 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:  Easy dialing plugin.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 

    20 #include "easydialingplugin.h"

    21 #include "easydialinglistbox.h"

    22 #include "easydialinglogger.h"

    23 #include "easydialingpanics.h"

    24 #include "easydialingcenreplistener.h"

    25 #include "easydialingcontactdatamanager.h"

    26 #include "easydialingutils.h"

    27 #include "easydialingcommands.hrh"

    28 #include <easydialingpluginresources.rsg>

    29 

    30 // AVKON and drawing header files

    31 #include <gdi.h>

    32 #include <aknlists.h>

    33 #include <AknUtils.h>

    34 #include <e32cmn.h>

    35 #include <bidivisual.h>

    36 

    37 #include <aknlayoutscalable_avkon.cdl.h>

    38 

    39 // Predictive search header files

    40 #include <CPsSettings.h>

    41 #include <CPsQuery.h>

    42 #include <CPsQueryItem.h>

    43 #include <CPsClientData.h>

    44 #include <CPsPattern.h>

    45 #include <CPsRequestHandler.h>

    46 

    47 // Virtual phonebook header files

    48 #include <VPbkContactStoreUris.h>

    49 #include <VPbkEng.rsg> // contains virtual phonebook data fields

    50 #include <phoneui.rsg> 

    51 

    52 // CCA Launcher header files.

    53 #include <ccafactory.h>

    54 #include <mccaparameter.h>

    55 #include <mccaconnection.h>

    56 #include <mccaconnectionext.h> 

    57 

    58 // Service provider settings api

    59 #include <spsettingsvoiputils.h>

    60 

    61 #include <StringLoader.h>

    62 

    63 // CCA contactor service.

    64 #include "edcontactorservice.h"

    65 

    66 // Open system trace

    67 #include "OstTraceDefinitions.h"

    68 #ifdef OST_TRACE_COMPILER_IN_USE

    69 #include "easydialingpluginTraces.h"

    70 #endif

    71 

    72 #include <phoneappcommands.hrh>

    73 #include <bautils.h>    // for BaflUtils

    74 

    75 // Transition effects

    76 #include <gfxtranseffect/gfxtranseffect.h>

    77 

    78 // EXTERNAL DATA STRUCTURES

    79 

    80 // EXTERNAL FUNCTION PROTOTYPES

    81 

    82 // CONSTANTS

    83 const TInt KEDMaximumMatchingContactsCount = 100;

    84 const TInt KEasyDialingListBoxModelGranularity = 8;

    85 const TInt KEasyDialingMaximumMatchingParts = 10;

    86 const TInt KErrEasyDialingNoFirstNamePCSIndexing = -2000;

    87 const TInt KErrEasyDialingNoLastNamePCSIndexing = -2001;

    88 

    89 const TInt KEDFlushContactDataManagerLimit = 20;

    90 

    91 const TText KHighlightSeparatorChar = 0x1F;

    92 _LIT(KHighlightSeparatorCharAsLiteral,"\x1F");

    93 const TText KListFieldSeparatorChar = '\t';

    94 

    95 const TText KArabicAndSouthEastAsianRangeStart = 0x0600;

    96 const TText KArabicAndSouthEastAsianRangeEnd = 0x19FF;

    97 const TText KArabicPresentationFormsARangenStart = 0xFB50;

    98 const TText KArabicPresentationFormsARangeEnd = 0xFDFF;

    99 const TText KArabicPresentationFormsBRangenStart = 0xFE70;

   100 const TText KArabicPresentationFormsBRangeEnd = 0xFEFF;

   101 

   102 const TInt KMaxRunInfoArrayCount = 20;

   103 

   104 // Transition context_uid for dialer_list component effects

   105 #define KGfxContactListBoxUid TUid::Uid( 0x2000B47B )

   106 const TInt KGfxContactListBoxOpenEffect  = 3;

   107 const TInt KGfxContactListBoxCloseEffect = 4;

   108 

   109 // MACROS

   110 

   111 // LOCAL CONSTANTS AND MACROS

   112 _LIT(KResourceFile, "\\resource\\easydialingpluginresources.rsc");

   113 

   114 // MODULE DATA STRUCTURES

   115 

   116 // LOCAL FUNCTION PROTOTYPES

   117 

   118 TInt CompareTPsMatchLocation( const TPsMatchLocation& a1, const TPsMatchLocation& a2 );

   119 

   120 void AppendStringWithMatchDataL(

   121         TDes& aBuffer,

   122         const TDesC& aText,

   123         CPSRequestHandler* aPSHandler,

   124         const CPsQuery* aPSQuery );

   125 

   126 TBool HighlightingSupportedForText( const TDesC& aText );

   127 

   128 inline TBool HighlightingSupportedForScript( TText aChar );

   129 

   130 TBool IsStrictlyBidirectional( const TDesC& aText );

   131 

   132 static HBufC* AllocWithoutHighlightSeparatorsLC( const TDesC& aDesc );

   133 

   134 static TBool IsItuTCharacter( TChar aChar );

   135 

   136 static TInt Find( const MVPbkContactLink* aLink, const RPointerArray<MVPbkContactLink>& aArray );

   137 

   138 template <class T>

   139 inline void CleanupResetAndDestroyPushL( T& aRef );

   140 

   141 

   142 

   143 // -----------------------------------------------------------------------------

   144 // CEasyDialingPlugin

   145 // The default c++ constructor

   146 // -----------------------------------------------------------------------------

   147 //

   148 CEasyDialingPlugin::CEasyDialingPlugin() 

   149     : iActionToBeLaunched( ENoActionDefined )

   150     {

   151     }

   152 

   153 // -----------------------------------------------------------------------------

   154 // NewL

   155 // Create instance of concrete ECOM interface implementation.

   156 // -----------------------------------------------------------------------------

   157 //

   158 CEasyDialingPlugin* CEasyDialingPlugin::NewL()

   159     {

   160     OstTrace0( TRACE_NORMAL, CEASYDIALINGPLUGIN_NEWL_LOAD_PLUGIN, "Loading plugin.." );

   161     LOGSTRING("EasyDialingPlugin: Loading plugin..");

   162 

   163     CEasyDialingPlugin* self = new (ELeave) CEasyDialingPlugin;

   164     CleanupStack::PushL( self );

   165     self->ConstructL();

   166     CleanupStack::Pop( self );

   167 

   168     OstTrace0( TRACE_NORMAL, CEASYDIALINGPLUGIN_NEWL_LOAD_PLUGIN_OK, "Loading plugin completed succesfully" );

   169     LOGSTRING("EasyDialingPlugin: Loading plugin completed succesfully");

   170     return self;

   171     }

   172 

   173 // -----------------------------------------------------------------------------

   174 // ConstructL

   175 // Main construction handled here. Creates connection to the predictive search

   176 // engine and initialises all member data.

   177 // -----------------------------------------------------------------------------

   178 //

   179 void CEasyDialingPlugin::ConstructL()

   180     {

   181     iLongTapped = EFalse;

   182     // Create contact data manager.

   183     iContactDataManager = CEasyDialingContactDataManager::NewL();

   184     iContactDataManager->SetObserver( this );

   185 

   186     // Find a handle to ca launcher extension MCCAConnectionExt.

   187     // Easydialing has to use the extension API, because it needs function CloseAppL

   188     // only found in extension.

   189     // MCCAConnection extension has to be obtained through MCCAParameter extension,

   190     // since MCCAConnection is not designed to be extensible API.

   191     MCCAParameter* parameter = TCCAFactory::NewParameterL();

   192     TAny* any = parameter->CcaParameterExtension( KMCCAConnectionExtUid );

   193     

   194     // Parameter can be deallocated since "any" containing pointer to contact launcher

   195     // is not tied to parameter in any way.

   196     parameter->Close();

   197     

   198     // Cast the pointer into contact launcher object. 

   199     User::LeaveIfNull( any );

   200     iContactLauncher = static_cast<MCCAConnectionExt*>( any );

   201     

   202     iCenrepListener = CEasyDialingCenrepListener::NewL( this );

   203    

   204     iContactorService = CEDContactorService::NewL( this );

   205 

   206     // EasyDialing resource file is attempted to be read from the same directory where the

   207     // executed binary is located

   208     TFileName dllFileName;

   209     Dll::FileName( dllFileName );

   210     

   211     TParse parse;

   212     User::LeaveIfError( parse.Set(KResourceFile, &dllFileName, NULL) );

   213     TFileName resourceFileName( parse.FullName() );

   214 

   215     BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), resourceFileName );

   216     iResourceFileOffset = iCoeEnv->AddResourceFileL( resourceFileName );

   217   

   218     SetComponentsToInheritVisibility( ETrue );

   219     }

   220 

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

   222 // ~CEasyDialingPlugin

   223 // The desctructor

   224 // -----------------------------------------------------------------------------

   225 //

   226 CEasyDialingPlugin::~CEasyDialingPlugin()

   227     {

   228     iObservers.Reset();

   229     

   230     delete iCenrepListener;

   231     delete iContactDataManager;

   232     delete iPredictiveSearchQuery;

   233     iContactDataStores.ResetAndDestroy();

   234 

   235     if ( iPredictiveContactSearchHandler )

   236         {

   237         iPredictiveContactSearchHandler->RemoveObserver(this);

   238         }

   239     delete iPredictiveContactSearchHandler;

   240 

   241     delete iListBoxModel;

   242     

   243     if ( iContactListBox )

   244         {

   245         GfxTransEffect::Deregister( iContactListBox );

   246         }

   247     

   248     delete iInfoLabelLine1;

   249     delete iInfoLabelLine2;

   250     delete iInfoLabelTextLine1;

   251     delete iInfoLabelTextLine2;

   252 

   253     delete iContactListBox;

   254 

   255     if ( iContactLauncher )

   256         {

   257         iContactLauncher->Close();

   258         }

   259     

   260     delete iContactorService;

   261     

   262     iCoeEnv->DeleteResourceFile( iResourceFileOffset );

   263     

   264     delete iInputBlocker;

   265     

   266     if ( iAsyncCallBack )

   267         {

   268         iAsyncCallBack->Cancel();

   269         }

   270     delete iAsyncCallBack;

   271     

   272     delete iContactToBeLaunched;

   273     delete iContactToBeLaunchedName;

   274     

   275     OstTrace0( TRACE_NORMAL, CEASYDIALINGPLUGIN_UNLOAD_PLUGIN, "Plugin unloaded" );

   276     LOGSTRING("EasyDialingPlugin: Plugin unloaded");

   277     }

   278 

   279 

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

   281 // InitializeL

   282 // Initialises easy dialing.

   283 // -----------------------------------------------------------------------------

   284 //

   285 void CEasyDialingPlugin::InitializeL( CCoeControl& aParent )

   286     {

   287     SetContainerWindowL( aParent );

   288     SetMopParent( &aParent );

   289     

   290     TCallBack asyncCallBack( AsyncCallBackToLaunchAction, this );

   291     iAsyncCallBack = new ( ELeave ) CAsyncCallBack( asyncCallBack, 

   292                                                     CActive::EPriorityStandard );

   293 

   294     iContactListBox = new (ELeave) CEasyDialingListBox();

   295     iListBoxModel = new(ELeave) CDesCArrayFlat( KEasyDialingListBoxModelGranularity );

   296 

   297     iContactListBox->ConstructL( CEikListBox::EPaintedSelection

   298             | CEikListBox::ENoFirstLetterMatching

   299             | CEikListBox::EDisableItemSpecificMenu, 

   300             iContactDataManager );

   301     iContactListBox->SetListBoxObserver(this);

   302 

   303     iContactListBox->SetMopParent(this);

   304 

   305     CTextListBoxModel* model = iContactListBox->Model();

   306     model->SetItemTextArray( iListBoxModel );

   307     model->SetOwnershipType( ELbmDoesNotOwnItemArray );

   308 

   309     iContactListBox->MakeVisible( EFalse );

   310     

   311     SetFocus( EFalse );

   312     iContactListBox->ActivateL();

   313     

   314     _LIT( KEDNewLine, "\n" );

   315     HBufC* infoLabelText = StringLoader::LoadLC( R_QTN_EASYDIAL_ENTER_NUMBER, iCoeEnv );

   316     TInt newLine = infoLabelText->Find( KEDNewLine );

   317     if ( newLine == KErrNotFound )

   318         {

   319         iInfoLabelTextLine1 = infoLabelText;

   320         CleanupStack::Pop( infoLabelText );

   321         iInfoLabelTextLine2 = HBufC::NewL(0);

   322         }

   323     else

   324         {

   325         iInfoLabelTextLine1 = infoLabelText->Left( newLine ).AllocL();

   326         iInfoLabelTextLine2 = infoLabelText->Mid( newLine + 1 ).AllocL();

   327         CleanupStack::PopAndDestroy( infoLabelText );

   328         }

   329             

   330     iInfoLabelLine1 = new( ELeave ) CEikLabel;

   331     iInfoLabelLine1->SetContainerWindowL( *this );

   332     iInfoLabelLine1->SetParent( this );

   333     iInfoLabelLine1->SetMopParent( this ); 

   334     iInfoLabelLine1->SetLabelAlignment( ELayoutAlignCenter );

   335     iInfoLabelLine1->SetTextL( *iInfoLabelTextLine1 );

   336     iInfoLabelLine1->ActivateL();

   337 

   338     iInfoLabelLine2 = new( ELeave ) CEikLabel;

   339     iInfoLabelLine2->SetContainerWindowL( *this );

   340     iInfoLabelLine2->SetParent( this );

   341     iInfoLabelLine2->SetMopParent( this ); 

   342     iInfoLabelLine2->SetLabelAlignment( ELayoutAlignCenter );

   343     iInfoLabelLine2->SetTextL( *iInfoLabelTextLine2 );

   344     iInfoLabelLine2->ActivateL();

   345 

   346     SetInfoLabelColourL();

   347     

   348     GfxTransEffect::Register( iContactListBox, 

   349                               KGfxContactListBoxUid, EFalse );

   350     

   351     iCoeEnv->AddForegroundObserverL( *this );

   352     

   353     // Do delayed initialization of PCS. PCS constructions takes a long time.

   354     // On the other hand, easy dialing initialization is done in phone application

   355     // constructor, so it contributes the whole system boot time. These are good 

   356     // reasons not to construct PCS in easy dialing constructor, but do it later as

   357     // an asynchronous operation.

   358     AsyncActionLaunchL( EInitializePcs );

   359     }

   360 

   361 

   362 // -----------------------------------------------------------------------------

   363 // Reset

   364 // Resets easydialing plugin.

   365 // -----------------------------------------------------------------------------

   366 //

   367 void CEasyDialingPlugin::Reset()

   368     {

   369     // PCS searches completing after the Reset() call must be discarded

   370     iDiscardCompletingSearches = ETrue;

   371     

   372     iNewSearchNeeded = EFalse;

   373     iSearchString.Zero();

   374     iListBoxModel->Reset();

   375     iNumberOfNames = 0;

   376     iContactListBox->MakeVisible( EFalse );

   377     iContactDataManager->Reset();

   378     if ( IsFocused() )

   379         {

   380         SetFocus( EFalse );

   381         }

   382     }

   383 

   384 

   385 // -----------------------------------------------------------------------------

   386 // InitPredictiveContactSearchL

   387 // Initialises predictive contact search.

   388 // -----------------------------------------------------------------------------

   389 //

   390 void CEasyDialingPlugin::InitPredictiveContactSearchL()

   391     {

   392     iPredictiveContactSearchHandler = CPSRequestHandler::NewL();

   393     iPredictiveContactSearchHandler->AddObserverL(this);

   394 

   395     // Check which relevant contact fields are indexed in PCS search.

   396     iFirstNamePCSIndex = FindContactFieldPCSIndexL( R_VPBK_FIELD_TYPE_FIRSTNAME );

   397     iLastNamePCSIndex = FindContactFieldPCSIndexL( R_VPBK_FIELD_TYPE_LASTNAME );

   398     iCompanyNamePCSIndex = FindContactFieldPCSIndexL( R_VPBK_FIELD_TYPE_COMPANYNAME );

   399 

   400     // If first name and last name are not indexed in PCS, easy dialing plugin

   401     // can not function reasonably. The function leaves, which in turn causes

   402     // the plugin not to be initialized.

   403     // Company name not being indexed is not as severe case, and does not cause a leave.

   404     // Fields used in PCS indexing are configured in cenrep 2000B5C6.

   405     if ( iFirstNamePCSIndex == KErrNotFound )

   406         {

   407         OstTrace0( TRACE_ERROR, CEASYDIALINGPLUGIN_INITPREDICTIVECONTACTSEARCHL_ERROR_NO_FIRST_NAME, "ERROR, PCS does not support first name indexing!" );

   408         LOGSTRING("EasyDialingPlugin: PCS does not support first name indexing => Leave");

   409         User::Leave( KErrEasyDialingNoFirstNamePCSIndexing );

   410         }

   411     if ( iLastNamePCSIndex == KErrNotFound )

   412         {

   413         OstTrace0( TRACE_ERROR, CEASYDIALINGPLUGIN_INITPREDICTIVECONTACTSEARCHL_ERROR_NO_LAST_NAME, "ERROR, PCS does not support last name indexing!" );

   414         LOGSTRING("EasyDialingPlugin: PCS does not support last name indexing => Leave");

   415         User::Leave( KErrEasyDialingNoLastNamePCSIndexing );

   416         }

   417 

   418     SetupPcsSettingsL();

   419 

   420     iPredictiveSearchQuery = CPsQuery::NewL();

   421     }

   422 

   423 // -----------------------------------------------------------------------------

   424 // SetupPcsSettingsL

   425 // -----------------------------------------------------------------------------

   426 //

   427 void CEasyDialingPlugin::SetupPcsSettingsL()

   428     {

   429     // Get current store configuration from Phonebook settings

   430     iContactDataStores.ResetAndDestroy();

   431     iContactDataManager->GetCurrentStoreUrisL( iContactDataStores );

   432     

   433     // Put the searched contact fields into array.

   434     RArray<TInt> contact_fields;

   435     CleanupClosePushL(contact_fields);

   436 

   437     // First name, last name and company name (if supported) are used in PCS search.

   438     contact_fields.Append( R_VPBK_FIELD_TYPE_FIRSTNAME );

   439     contact_fields.Append( R_VPBK_FIELD_TYPE_LASTNAME );

   440     contact_fields.Append( R_VPBK_FIELD_TYPE_COMPANYNAME );

   441 

   442     // Create and fill PS settings object.

   443     CPsSettings* ps_settings = CPsSettings::NewL();

   444     CleanupStack::PushL( ps_settings );

   445 

   446     ps_settings->SetSearchUrisL( iContactDataStores );

   447     ps_settings->SetMaxResults( KEDMaximumMatchingContactsCount );

   448     ps_settings->SetSortType( EAlphabetical );

   449     ps_settings->SetDisplayFieldsL( contact_fields );

   450 

   451     // Set the PCS settings.

   452     iPredictiveContactSearchHandler->SetSearchSettingsL( *ps_settings );

   453 

   454     CleanupStack::PopAndDestroy( ps_settings );

   455     CleanupStack::PopAndDestroy( &contact_fields );

   456 

   457     // Set the sort order. This must happen after the contact store settings

   458     // are up-to-date.

   459     SetSortOrderL( iContactDataManager->NameOrder() );

   460     }

   461 

   462 // -----------------------------------------------------------------------------

   463 // SetSortOrderL

   464 // -----------------------------------------------------------------------------

   465 //

   466 void CEasyDialingPlugin::SetSortOrderL( CEasyDialingContactDataManager::TNameOrder aNameOrder )

   467     {

   468     RArray<TInt> fields;

   469     CleanupClosePushL( fields );

   470     if ( aNameOrder == CEasyDialingContactDataManager::EFirstnameLastname )

   471         {

   472         fields.AppendL( R_VPBK_FIELD_TYPE_FIRSTNAME );

   473         fields.AppendL( R_VPBK_FIELD_TYPE_LASTNAME );

   474         }

   475     else

   476         {

   477         fields.AppendL( R_VPBK_FIELD_TYPE_LASTNAME );

   478         fields.AppendL( R_VPBK_FIELD_TYPE_FIRSTNAME );

   479         }

   480     fields.AppendL( R_VPBK_FIELD_TYPE_COMPANYNAME );

   481     

   482     // Set the same order for each contact store. PCS automatically ignores

   483     // fields not supported by the given store.

   484     for ( TInt i = 0 ; i < iContactDataStores.Count() ; ++i )

   485         {

   486         iPredictiveContactSearchHandler->ChangeSortOrderL( *iContactDataStores[i], fields );

   487         }

   488     CleanupStack::PopAndDestroy( &fields );

   489     }

   490 

   491 // -----------------------------------------------------------------------------

   492 // OfferKeyEventL

   493 // Check the received keypad event and performs user

   494 // actions related to it.

   495 // -----------------------------------------------------------------------------

   496 //

   497 TKeyResponse CEasyDialingPlugin::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

   498     {

   499     TKeyResponse keyResponse = EKeyWasNotConsumed;

   500 

   501     if ( aType != EEventKey )

   502         {

   503         return keyResponse;

   504         }

   505 

   506     TInt keyCode = aKeyEvent.iCode;

   507     

   508     // Swap right and left key codes in mirrored layout.

   509     if ( AknLayoutUtils::LayoutMirrored() ) 

   510         {

   511         if ( keyCode == EKeyRightArrow ) keyCode = EKeyLeftArrow;

   512         else if ( keyCode == EKeyLeftArrow ) keyCode = EKeyRightArrow;

   513         }

   514     

   515 

   516     if ( IsFocused() )

   517         {

   518         if ( keyCode == EKeyUpArrow )

   519             {

   520             // if the focus is on the top-most item

   521             if ( iContactListBox->CurrentItemIndex() == 0)

   522                 {

   523                 // then focus jumps off the component.

   524                 SetFocus( EFalse );

   525                 DrawDeferred();

   526                 keyResponse = EKeyWasConsumed;

   527                 }

   528             else

   529                 {

   530                 keyResponse = iContactListBox->OfferKeyEventL( aKeyEvent, aType );

   531                 }

   532             }

   533         else if ( keyCode == EKeyDownArrow )

   534             {

   535             // if the focus is on the bottom-most item

   536             if ( iContactListBox->CurrentItemIndex() == (iNumberOfNames - 1) )

   537                 {

   538                 // then focus jumps off the component.

   539                 SetFocus( EFalse );

   540                 DrawDeferred();

   541                 keyResponse = EKeyWasConsumed;

   542                 }

   543             else

   544                 {

   545                 keyResponse = iContactListBox->OfferKeyEventL( aKeyEvent, aType );

   546                 }

   547             }

   548 

   549         else if ( keyCode == EKeyRightArrow )

   550             {

   551             iRememberFocus = ETrue;

   552             AsyncActionLaunchL( ELaunchCurrentContact );

   553             keyResponse = EKeyWasConsumed;

   554             }

   555 

   556         else if ( keyCode == EKeyLeftArrow )

   557             {

   558             // then focus jumps off the component.

   559             SetFocus( EFalse );

   560             DrawDeferred();

   561             keyResponse = EKeyWasConsumed;

   562             }

   563 

   564         else

   565             {

   566             // then focus jumps off the component.

   567             SetFocus( EFalse );

   568             

   569             // FEP hasn't had chance to handle this key event as focus was not in the editor field.

   570             // Give that chance now by consuming original event and simulating a new one.

   571             // The simulation must be asynchronous because FEP focusing state is updated

   572             // with high priority active object.

   573             // As an exception, dialer simulated keys are given directly to editor. They are

   574             // not handled by FEP anyway, and asynchronous handling would be problematic for

   575             // the * key multitapping logic of Phone.

   576             TBool simulatedByDialer = (aKeyEvent.iModifiers&EModifierNumLock) &&

   577                                       (aKeyEvent.iModifiers&EModifierKeypad);

   578             if ( !simulatedByDialer )

   579                 {

   580                 keyResponse = EKeyWasConsumed;

   581                 AsyncSimulateKeyEvent( aKeyEvent );

   582                 }

   583             }

   584         }

   585 

   586     else if ( iNumberOfNames > 0 ) // not in focus but there are contacts to show

   587         {

   588         if ( keyCode == EKeyUpArrow || keyCode == EKeyDownArrow )

   589             {

   590             SetFocus( ETrue );

   591             keyResponse = iContactListBox->SetFocusedWithKeyEventL( aKeyEvent, aType );

   592             }

   593         }

   594     return keyResponse;

   595     }

   596 

   597 

   598 // -----------------------------------------------------------------------------

   599 // CountComponentControls

   600 //

   601 // -----------------------------------------------------------------------------

   602 //

   603 TInt CEasyDialingPlugin::CountComponentControls() const

   604     {

   605     return iNumberOfNames > 0 ? 3 : 2;

   606     }

   607 

   608 

   609 // -----------------------------------------------------------------------------

   610 // ComponentControl

   611 //

   612 // -----------------------------------------------------------------------------

   613 //

   614 CCoeControl* CEasyDialingPlugin::ComponentControl( TInt aIndex ) const

   615     {

   616     switch ( aIndex )

   617         {

   618         case 0:

   619             return iInfoLabelLine1;

   620         case 1:

   621             return iInfoLabelLine2;

   622         case 2:

   623             return iContactListBox;

   624         default:

   625             return NULL;

   626         }

   627     }

   628 

   629 

   630 // -----------------------------------------------------------------------------

   631 // MakeVisible

   632 //

   633 // -----------------------------------------------------------------------------

   634 //

   635 void CEasyDialingPlugin::MakeVisible( TBool aVisible )

   636     {

   637     if ( aVisible != IsVisible() )

   638         {

   639         CCoeControl::MakeVisible( aVisible );

   640         

   641         if ( !aVisible && IsFocused() )

   642             {

   643             SetFocus( EFalse );

   644             }

   645         }

   646     }

   647 

   648 // -----------------------------------------------------------------------------

   649 // HandleResourceChange

   650 //

   651 // -----------------------------------------------------------------------------

   652 //

   653 void CEasyDialingPlugin::HandleResourceChange( TInt /*aType*/ )

   654     {

   655     TRAP_IGNORE( SetInfoLabelColourL() );

   656     }

   657 

   658 // -----------------------------------------------------------------------------

   659 // SizeChanged

   660 //

   661 // -----------------------------------------------------------------------------

   662 //

   663 void CEasyDialingPlugin::SizeChanged()

   664     {

   665     TRect rect = Rect();

   666     // convert rect to absolute coordinates

   667     rect.SetRect( PositionRelativeToScreen(), rect.Size() );

   668     

   669     iContactListBox->SetMaxRect( rect );

   670     iContactListBox->SetRectToNumberOfItems( iNumberOfNames );

   671     

   672     TInt itemToMakeVisible = iContactListBox->CurrentItemIndex();  

   673     if ( itemToMakeVisible == KErrNotFound && iNumberOfNames )

   674         {

   675         // if no current item is set, make sure that the list is then 

   676         // scrolled to the bottom.

   677         itemToMakeVisible = iNumberOfNames - 1;

   678         } 

   679     iContactListBox->ScrollToMakeItemVisible( itemToMakeVisible );

   680 

   681     // get info label locations and fonts from layout

   682     TRect baseRect = Rect();

   683     TAknTextComponentLayout labelLayoutLine1 = 

   684         AknLayoutScalable_Avkon::main_pane_empty_t1( 0 );

   685     TAknTextComponentLayout labelLayoutLine2 = 

   686         AknLayoutScalable_Avkon::main_pane_empty_t2( 0 );

   687     AknLayoutUtils::LayoutLabel( iInfoLabelLine1, baseRect, labelLayoutLine1 );

   688     AknLayoutUtils::LayoutLabel( iInfoLabelLine2, baseRect, labelLayoutLine2 );

   689     

   690     // the layouts used place the text too low, so center the labels vertically

   691     TInt labelHeight = iInfoLabelLine2->Rect().iBr.iY - iInfoLabelLine1->Rect().iTl.iY;

   692     TInt centeredTop = ( baseRect.Height() - labelHeight ) / 2;

   693     TInt offset = centeredTop - iInfoLabelLine1->Rect().iTl.iY;

   694     iInfoLabelLine1->SetPosition( TPoint( iInfoLabelLine1->Rect().iTl.iX,

   695                                           iInfoLabelLine1->Rect().iTl.iY + offset ) );

   696     iInfoLabelLine2->SetPosition( TPoint( iInfoLabelLine2->Rect().iTl.iX,

   697                                           iInfoLabelLine2->Rect().iTl.iY + offset ) );

   698     

   699     TRAP_IGNORE( SetInfoLabelColourL() );

   700     }

   701 

   702 

   703 // -----------------------------------------------------------------------------

   704 // FocusChanged

   705 //

   706 // -----------------------------------------------------------------------------

   707 //

   708 void CEasyDialingPlugin::FocusChanged( TDrawNow aDrawNow )

   709     {

   710     iContactListBox->SetFocus( IsFocused() );

   711     if ( !IsFocused() )

   712         {

   713         // To be on the safe side, cancel async callback and reset input block.

   714         CancelActionLaunchAndInputBlock();

   715         iContactListBox->View()->ItemDrawer()->ClearFlags( CListItemDrawer::ESingleClickDisabledHighlight );

   716         }

   717     CCoeControl::FocusChanged( aDrawNow );

   718     InformObservers( MDialingExtensionObserver::EFocusChanged );

   719     }

   720 

   721 

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

   723 // SetInputL

   724 //

   725 // -----------------------------------------------------------------------------

   726 //

   727 void CEasyDialingPlugin::SetInputL( const TDesC& aSearchString )

   728     {

   729     if ( !IsEnabled() )

   730         {

   731         return;

   732         }

   733     OstTraceExt1( TRACE_NORMAL, CEASYDIALINGPLUGIN_SET_INPUT, "SetInput: '%S' ", aSearchString );

   734     LOGSTRING1("EasyDialingPlugin: SetInput: '%S'", &aSearchString );

   735     

   736     // Earlier here was a test if the search string is the same as the one used in previous search.

   737     // If it was, no search was done but function returned immediately.

   738     // This has now been removed. It is possible that contacts have changed, and a new search

   739     // may be needed even if the search string is the same. 

   740     

   741     // Check if search string is just empty space or 0-length. Decision was made that no

   742     // matches are shown if search string is just space (would show all contacts)

   743     // even if somebody might have unnamed contacts. Should be quite rare.

   744     // It's assumed later on in the code that string is not just empty space.

   745     TLex searchString( aSearchString );

   746     searchString.SkipSpace();

   747     if ( searchString.Eos() ) // the end of the string reached after skipping empty space

   748         {

   749         // It's assumed here that if we get here due to switching to call

   750         // handling etc, then dialer and thus ed is already set invisible

   751         // and effect will not be shown as listbox is already invisible.

   752         // However if user empties number entry, then it's feasible to show

   753         // effect.

   754         HideContactListBoxWithEffect();

   755         SetInfoLabelVisibleL( ETrue );

   756         Reset();

   757         }

   758     else // proper search string

   759         {

   760         SetInfoLabelVisibleL( EFalse );

   761         iSearchString.Copy( aSearchString.Left( iSearchString.MaxLength() ) );

   762         LaunchSearchL();

   763         }

   764     }

   765 

   766 

   767 // -----------------------------------------------------------------------------

   768 // MatchingContactCount

   769 //

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

   771 //

   772 TInt CEasyDialingPlugin::MatchingContactCount()

   773     {

   774     return iNumberOfNames;

   775     }

   776 

   777 

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

   779 // EasyDialingSettingsChanged

   780 // From MEasyDialingCenrepListenerObserver

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

   782 //

   783 void CEasyDialingPlugin::EasyDialingSettingsChanged( TInt aValue )

   784     {

   785     if ( aValue == 0 )

   786         {

   787         Reset();

   788         InformObservers( MDialingExtensionObserver::EEasyDialingDisabled );

   789         TRAP_IGNORE( SetInfoLabelVisibleL( EFalse ) );

   790         }

   791     else if ( aValue == 1 )

   792         {

   793         InformObservers( MDialingExtensionObserver::EEasyDialingEnabled );

   794         if ( iSearchString.Length() == 0 )

   795             {

   796             TRAP_IGNORE( SetInfoLabelVisibleL( ETrue ) );

   797             }

   798         }

   799     MakeVisible( aValue );

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // EasyDialingContactThumbnailsSettingsChanged

   804 // From MEasyDialingCenrepListenerObserver

   805 // -----------------------------------------------------------------------------

   806 //

   807 void CEasyDialingPlugin::EasyDialingContactThumbnailsSettingsChanged( TInt aThumbnailSettingValue )

   808     {

   809     iContactDataManager->SetContactThumbnailSetting( aThumbnailSettingValue );

   810     iContactDataManager->Reload();

   811     DrawDeferred();

   812     }

   813 

   814 // -----------------------------------------------------------------------------

   815 // AllContactDataLoaded

   816 // From MContactDataManagerObserver

   817 // -----------------------------------------------------------------------------

   818 //

   819 void CEasyDialingPlugin::AllContactDataLoaded()

   820     {

   821     iContactListBox->DrawDeferred();

   822     }

   823 

   824 // -----------------------------------------------------------------------------

   825 // NameOrderChanged

   826 // From MContactDataManagerObserver

   827 // -----------------------------------------------------------------------------

   828 //

   829 void CEasyDialingPlugin::NameOrderChanged()

   830     {

   831     if ( iPredictiveContactSearchHandler )

   832         {

   833         TRAP_IGNORE( SetSortOrderL( iContactDataManager->NameOrder() ) );

   834         // Refresh current results if needed

   835         TRAP_IGNORE( DoHandleContactsChangedL() );

   836         }

   837     }

   838 

   839 // -----------------------------------------------------------------------------

   840 // FavouritesChanged

   841 // From MContactDataManagerObserver

   842 // -----------------------------------------------------------------------------

   843 //

   844 void CEasyDialingPlugin::FavouritesChanged()

   845     {

   846     TRAP_IGNORE( DoHandleContactsChangedL() );

   847     }

   848 

   849 // -----------------------------------------------------------------------------

   850 // StoreConfigurationChanged

   851 // From MContactDataManagerObserver

   852 // -----------------------------------------------------------------------------

   853 //

   854 void CEasyDialingPlugin::StoreConfigurationChanged()

   855     {

   856     TRAP_IGNORE( 

   857         // Reconfigure PCS to update its store settings

   858         SetupPcsSettingsL();

   859         // Contacts available have changed and a new search is needed if we have

   860         // previous results shown.

   861         DoHandleContactsChangedL() 

   862         );

   863     }

   864 

   865 // -----------------------------------------------------------------------------

   866 // InformContactorEvent

   867 // From MEDContactorObserver

   868 // -----------------------------------------------------------------------------

   869 //

   870 void CEasyDialingPlugin::InformContactorEvent( MEDContactorObserver::TEvent aEvent )

   871     {

   872     // This callback function simply propagates the events to its own listener.

   873     switch ( aEvent )

   874         {

   875         case MEDContactorObserver::ECommunicationStarted:

   876             InformObservers( MDialingExtensionObserver::ECommunicationStarted );

   877             break;

   878         case MEDContactorObserver::ECommunicationCancelled:

   879             InformObservers( MDialingExtensionObserver::ECommunicationCancelled );

   880             break;

   881         default:

   882             break;

   883         }

   884     

   885     // Reset focus unless it is flagged to be remembered.

   886     if ( !iRememberFocus )

   887         {

   888         SetFocus( EFalse );

   889         DrawDeferred();

   890         }

   891     

   892     iRememberFocus = EFalse;

   893     }

   894 

   895 // -----------------------------------------------------------------------------

   896 // Draw

   897 // The actual UI drawing function. Draws the easy dialing popup bubble on the

   898 // idle screen.

   899 // -----------------------------------------------------------------------------

   900 //

   901 void CEasyDialingPlugin::Draw( const TRect& /* aRect */ ) const

   902     {

   903     }

   904 

   905 

   906 // -----------------------------------------------------------------------------

   907 // LaunchSearchL

   908 // Initiates predictive contact search.

   909 // -----------------------------------------------------------------------------

   910 //

   911 void CEasyDialingPlugin::LaunchSearchL()

   912     {

   913     if ( iSearchString.Length() == 0 || !iPredictiveContactSearchHandler )

   914         {

   915         return;

   916         }

   917     

   918     iDiscardCompletingSearches = EFalse;

   919     iNewSearchNeeded = EFalse;

   920     

   921     iPredictiveSearchQuery->Reset();

   922 

   923     for ( TInt i = 0; i < iSearchString.Length(); i++ )

   924         {

   925          // Add a query item

   926         CPsQueryItem* item = CPsQueryItem::NewL();

   927         CleanupStack::PushL(item);

   928 

   929         item->SetCharacter( iSearchString[i] );

   930         

   931         // The PCS mode used with character is based on character itself,

   932         // not to the keyboard it is made with. While this is not strictly

   933         // identical to checking the used keyboard, this behaves identically

   934         // in most of the normal cases, and makes the logic simpler.

   935         // In case of hybrid mode keyboard, use always predictive default 

   936         // keyboard.

   937         if ( iKeyboardMode == EDefaultKeyboard && 

   938              IsItuTCharacter( iSearchString[i] ) )

   939             {

   940             item->SetMode( EPredictiveItuT );

   941             }

   942         else 

   943             {

   944             item->SetMode( EPredictiveDefaultKeyboard );

   945             }

   946         

   947         iPredictiveSearchQuery->AppendL(*item);

   948 

   949         // Previous CPsQuery::AppendL takes the ownership of item.

   950         // Do not delete item.

   951         CleanupStack::Pop(item);

   952         }

   953 

   954     // Issue the search. SearchL is asynchronous function => returns immediately.

   955     iPredictiveContactSearchHandler->SearchL(*iPredictiveSearchQuery);

   956     }

   957 

   958 

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

   960 // HandlePsResultsUpdate from MPsResultsObserver

   961 // Called after predictive search has been completed.

   962 // -----------------------------------------------------------------------------

   963 //

   964 void CEasyDialingPlugin::HandlePsResultsUpdate( RPointerArray<CPsClientData>& aResults, RPointerArray<CPsPattern>& aSeqs )

   965     {

   966     if ( !IsEnabled() )

   967         {

   968         // Easydialing is off. We should arrive here only if user turned it off while a search was happening.

   969         Reset();

   970         return;

   971         }

   972     TRAPD( leaveError, HandlePsResultsUpdateL( aResults, aSeqs ) );

   973 

   974     if ( leaveError )

   975         {

   976         OstTrace1( TRACE_ERROR, CEASYDIALINGPLUGIN_HANDLEPSRESULTSUPDATE, "HandlePsResultsUpdate failed: %d", leaveError );

   977         LOGSTRING1("EasyDialingPlugin: HandlePsResultsUpdate failed: %d", leaveError );

   978         }

   979     }

   980 

   981 

   982 // -----------------------------------------------------------------------------

   983 // HandlePsError from MPsResultsObserver

   984 // Called when search error happens.

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

   986 //

   987 void CEasyDialingPlugin::HandlePsError( TInt aErrorCode )

   988     {

   989     OstTrace1( TRACE_ERROR, CEASYDIALINGPLUGIN_HANDLEPSERROR, "PCS Error: %d", aErrorCode );

   990     LOGSTRING1("EasyDialingPlugin: PCS Error: %d", aErrorCode );

   991     }

   992 

   993 // -----------------------------------------------------------------------------

   994 // CachingStatus from MPsResultsObserver

   995 // Called to update caching status.

   996 // -----------------------------------------------------------------------------

   997 //

   998 void CEasyDialingPlugin::CachingStatus( TCachingStatus& aStatus, TInt& aError )

   999     {

  1000     OstTraceExt2( TRACE_NORMAL, CEASYDIALINGPLUGIN_CACHINGSTATUS, "PCS CachingStatus: %d, error: %d", ( TUint )( aStatus ), aError );

  1001     

  1002     switch ( aStatus )

  1003         {

  1004         case ECacheUpdateContactRemoved:

  1005         case ECacheUpdateContactModified:

  1006         case ECacheUpdateContactAdded:

  1007             TRAP_IGNORE( DoHandleContactsChangedL() );

  1008             break;

  1009         default:

  1010             break;

  1011         }

  1012     

  1013     LOGSTRING2("EasyDialingPlugin: PCS CachingStatus: %d, error: %d", aStatus, aError );

  1014     }

  1015 

  1016 

  1017 // -----------------------------------------------------------------------------

  1018 // FindContactFieldPCSIndex

  1019 // Searches the index that stores the given contact field.

  1020 // To see possible contact field numbering, see file "vpbkeng.rsg".

  1021 // -----------------------------------------------------------------------------

  1022 //

  1023 TInt CEasyDialingPlugin::FindContactFieldPCSIndexL( TInt aIndex )

  1024     {

  1025     RArray<TInt> fieldOrder;

  1026     CleanupClosePushL( fieldOrder );

  1027 

  1028     // PCS uses the same data plugin for all the Phonebook databases

  1029     // (i.e. phone contacts, SIM contacts, SDN contacts), and there can be only

  1030     // one data order per plugin. Thus, data order for all databases supported

  1031     // by us is the same, and it's enough to ask data order just for the default CDB.

  1032     const TDesC& defaultCdb = VPbkContactStoreUris::DefaultCntDbUri();

  1033 

  1034     iPredictiveContactSearchHandler->GetDataOrderL( defaultCdb, fieldOrder );

  1035     TInt pcsIndex = fieldOrder.Find( aIndex );

  1036 

  1037     CleanupStack::PopAndDestroy( &fieldOrder );

  1038     return pcsIndex;

  1039     }

  1040 

  1041 

  1042 // -----------------------------------------------------------------------------

  1043 // HandlePsResultsUpdateL

  1044 // This function does the actual callback fork, and must be trapped inside

  1045 // HandlePsResultsUpdateL.

  1046 // -----------------------------------------------------------------------------

  1047 //

  1048 void CEasyDialingPlugin::HandlePsResultsUpdateL( RPointerArray<CPsClientData>& aResults, RPointerArray<CPsPattern>& /*aSeqs*/ )

  1049     {

  1050     // If iDiscardCompletingSearches is ETrue, don't show search results but just return.

  1051     // If easydialing has been reset with reset function, no searches completed after that

  1052     // can be shown.

  1053     // This is done like this because there seems not to be a feasible way of cancelling all 

  1054     // PCS search request in PCS API. CancelRequest does not work here.

  1055     if ( iDiscardCompletingSearches )

  1056         {

  1057         return;

  1058         }

  1059     

  1060     iListBoxModel->Reset();

  1061     iContactListBox->HandleItemRemovalL();

  1062 

  1063     TInt numberOfPCSMatches( aResults.Count() );

  1064     

  1065     // Resetting the contactdatamanager causes the thumbnails to flicker a bit, because

  1066     // we need to load the thumbnails again. But if there are lots of search results, or

  1067     // lots of loaded thumbnails in the manager, matching the search results to the

  1068     // thumbnail manager contents may take too much time. If there are lots of results,

  1069     // it is likely that the contents of the listbox change anyway, so the flickering

  1070     // doesn't matter too much. This also limits the memory usage of the manager.

  1071     //   But if there are fewer search results, it is worth trying to match them

  1072     // with the contents of thumbnail manager.

  1073     

  1074     TBool matchThumbnails(ETrue);

  1075     if ( numberOfPCSMatches > KEDFlushContactDataManagerLimit )

  1076         {

  1077         iContactDataManager->Reset();

  1078         matchThumbnails = EFalse;

  1079         }

  1080 

  1081     OstTrace1( TRACE_NORMAL, CEASYDIALINGPLUGIN_HANDLEPSRESULTSUPDATEL_MATCHES, "Matching results from PCS: %d", numberOfPCSMatches );

  1082     LOGSTRING1("EasyDialingPlugin: Matching results from PCS: %d", numberOfPCSMatches );

  1083 

  1084     // retrieve the name order before adding

  1085     CEasyDialingContactDataManager::TNameOrder nameOrder = iContactDataManager->NameOrder();

  1086 

  1087     RPointerArray<MVPbkContactLink> favsFoundByPcs;

  1088     CleanupResetAndDestroyPushL( favsFoundByPcs );

  1089     

  1090     // Update the model

  1091     // ----------------

  1092     for ( TInt i = 0; i < numberOfPCSMatches; i++ )

  1093         {

  1094         TInt indexFromEnd = numberOfPCSMatches - i - 1;

  1095 

  1096         MVPbkContactLink* link = iPredictiveContactSearchHandler->ConvertToVpbkLinkLC(

  1097                 *(aResults[indexFromEnd]), iContactDataManager->ContactManager() );

  1098         if ( !iContactDataManager->IsFavL( link ) )

  1099             {

  1100             // handle favourites separately, in another loop

  1101             HBufC* contactString = CreateContactStringLC( aResults[ indexFromEnd ], nameOrder );

  1102             CreateListBoxContactStringL( *contactString, link, matchThumbnails, EFalse );

  1103             CleanupStack::PopAndDestroy( contactString );

  1104             CleanupStack::PopAndDestroy( link );

  1105             }

  1106         else

  1107             {

  1108             // favourites are handled later

  1109             favsFoundByPcs.AppendL( link );

  1110             CleanupStack::Pop( link );

  1111             }

  1112         

  1113         OstTraceExt2( TRACE_NORMAL, CEASYDIALINGPLUGIN_HANDLEPSRESULTSUPDATEL_SHOW_MATCH, "Contact #%d: '%S'", i+1, iContactStringCreationBuffer );

  1114         LOGSTRING2( "EasyDialingPlugin: Contact #%d: '%S'", i+1, &iContactStringCreationBuffer );

  1115         }

  1116 

  1117     // Search synchronously through all the favourite contacts to ensure

  1118     // that all favourite matches are added to bottom even when number of mathces

  1119     // exceeds the maximum number set to PCS

  1120     TInt numberOfFavs( iContactDataManager->NumberOfFavsL() );

  1121     TBuf<KBufferMaxLen> results;

  1122     for ( TInt i = numberOfFavs - 1; i >= 0; i-- )

  1123         {

  1124         HBufC* favContactString = iContactDataManager->FavContactStringLC( i, nameOrder );

  1125         MVPbkContactLink* link = iContactDataManager->FavLinkLC( i );

  1126         

  1127         // Check if this fav contact was returned in aResults.

  1128         // It's at least theoretically possible that all matches in aResults

  1129         // are not matched when using LookupMatchL. PCS has completely separate logics

  1130         // for functions SearchL and LookupMatchL and especially with Chinese variant

  1131         // they may return different results.

  1132         TBool found = ( Find( link, favsFoundByPcs ) != KErrNotFound );

  1133         

  1134         // If this fav contact was not in aResults, then use LookupMatchL