diff -r c84cf270c54f -r 8871b09be73b phoneuis/easydialing/tsrc/edta/src/edta_appview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phoneuis/easydialing/tsrc/edta/src/edta_appview.cpp Fri Feb 19 22:50:26 2010 +0200 @@ -0,0 +1,872 @@ +/* +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Easy dialing test application. +* +*/ + +// INCLUDE FILES +#include +#include +#include "edta_appview.h" +#include "edta_debugprint.h" +#include "edta_dummylistener.h" +#include + +// AVKON components +#include +#include + +// Predictive search header files. +#include +#include +#include +#include +#include +#include + +// Virtual phonebook header files. +#include +#include +#include +// contains virtual phonebook data fields +#include + +// Phonebook engine API +#include + +// CCA Launcher header files. +#include +#include +#include + + +const TInt KEdtaMaximumMatchingCount = 100; +const TInt KEdtaContactCompanyIndex = 2; +const TInt KEdtaContactEmailHomeIndex = 3; +const TInt KEdtaContactEmailWorkIndex = 4; +const TInt KEdtaContactEmailGenIndex = 5; +const TInt KEdtaListBoxGranularity = 5; + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// NewL +// First phase constructor without cleanup stack. +// ----------------------------------------------------------------------------- +// +CEdtaAppView* CEdtaAppView::NewL( const TRect& aRect ) + { + CEdtaAppView* self = CEdtaAppView::NewLC( aRect ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// NewLC +// First phase constructor with cleanup stack. +// ----------------------------------------------------------------------------- +// +CEdtaAppView* CEdtaAppView::NewLC( const TRect& aRect ) + { + CEdtaAppView* self = new ( ELeave ) CEdtaAppView; + CleanupStack::PushL( self ); + self->ConstructL( aRect ); + return self; + } + +// ----------------------------------------------------------------------------- +// ConstructL +// Second phase constructor. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::ConstructL( const TRect& aRect ) + { + DebugPrintF(_L("CEdtaAppView::ConstructL enter, rect: %d, %d - %d, %d"), aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY ); + + // Create a window for this application view + CreateWindowL(); + + const TDesC& thname = RThread().Name(); + iScreenBuffer = CEdtaScreenTextBuffer::NewL( aRect ); + iScreenBuffer->SetFocus( ETrue ); + iScreenBuffer->WriteLineL(thname); + + LoadPluginL(); + + DebugPrintF(_L("CEdtaAppView::ConstructL: iScreenBuffer: 0x%X, iEasyDialer: 0x%X"), iScreenBuffer, iEasyDialer ); + + if (iEasyDialer) + { + DebugPrintF(_L("CEdtaAppView::ConstructL: Easydialer plugin found, adding observer..") ); + + iEasyDialer->AddObserverL( this ); + iEasyDialer->SetFocus( EFalse ); + + DebugPrintF(_L("CEdtaAppView::ConstructL: Add observer done")); + } + + // Init PCS Server.. + TRAPD( error, InitPredictiveContactSearchL()); + if( error ) + { + DebugPrintF(_L("CEdtaAppView::ConstructL: Failed to load predictive search engine: %d"), error ); + iScreenBuffer->WriteLineL(_L("* PCS Server load fail: %d"), error ); + } + + // Init Communication Launcher.. + TRAP( error, iContactLauncher = TCCAFactory::NewConnectionL()); + if( error ) + { + DebugPrintF(_L("CEdtaAppView::ConstructL: Failed connect communication launcher: %d"), error ); + iScreenBuffer->WriteLineL(_L("* CCA open fail: %d"), error ); + } + + iDummyListener = new ( ELeave ) CDummyListener(); + + // Set the windows size + SetRect( aRect ); + ActivateL(); + + DebugPrintF(_L("CEdtaAppView::ConstructL exit")); + } + +// ----------------------------------------------------------------------------- +// CEdtaAppView +// The C++ default constructor can NOT contain any code, that might leave. +// ----------------------------------------------------------------------------- +// +CEdtaAppView::CEdtaAppView() + { + // No implementation here + } + +// ----------------------------------------------------------------------------- +// ~CEdtaAppView +// The destructor. +// ----------------------------------------------------------------------------- +// +CEdtaAppView::~CEdtaAppView() + { + DebugPrintF(_L("CEdtaAppView::~CEdtaAppView enter, iEasyDialer: 0x%x"), iEasyDialer ); + + delete iDummyListener; + + if (iEasyDialer) + { + iEasyDialer->RemoveObserver( this ); + } + + if (iPredictiveContactSearchHandler) + { + iPredictiveContactSearchHandler->RemoveObserver(this); + } + + delete iEasyDialer; + iContactNames.ResetAndDestroy(); + iMatchingContactLinks.ResetAndDestroy(); + + if (iContactLauncher) + { + iContactLauncher->Close(); + } + + delete iPredictiveSearchQuery; + delete iContactManager; + delete iPredictiveContactSearchHandler; + delete iContactStoreUriArray; + iContactDataStores.ResetAndDestroy(); + + delete iScreenBuffer; + DebugPrintF(_L("CEdtaAppView::~CEdtaAppView exit")); + } + + +// ----------------------------------------------------------------------------- +// Draw +// Draw itself. Clear the canvas. +// ----------------------------------------------------------------------------- +// + +void CEdtaAppView::Draw( const TRect& aRect ) const + { + DebugPrintF(_L("CEdtaAppView::Draw, rect: %d, %d - %d, %d"), aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY ); + + CWindowGc& gc = SystemGc(); + gc.SetClippingRect( aRect ); + + gc.SetBrushColor( KRgbWhite ); + gc.SetBrushStyle( CGraphicsContext::ESolidBrush ); + gc.Clear( aRect ); + } + + +// ----------------------------------------------------------------------------- +// SizeChanged +// Called by framework when the view size is changed. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::SizeChanged() + { + DebugPrintF(_L("CEdtaAppView::SizeChanged: iScreenBuffer: 0x%X, iEasyDialer: 0x%X"), iScreenBuffer, iEasyDialer ); + + // Controls must set rects, otherwise not drawn + // If easy dialer plugin is loaded, the controls are reorganized to screen. + if( iEasyDialer ) + { + // Screen buffer occupies upper half of the view. + TRect screen_buffer_rect = iAvkonAppUi->ClientRect(); + screen_buffer_rect.iBr.iY -= (screen_buffer_rect.Height() / 2 ); + TRect easy_dialer_rect(0, screen_buffer_rect.Height(), screen_buffer_rect.Width(), iAvkonAppUi->ClientRect().Height()); + iEasyDialer->SetRect( easy_dialer_rect ); + iScreenBuffer->SetRect(screen_buffer_rect); + } + else if ( iScreenBuffer ) + { + iScreenBuffer->SetRect(iAvkonAppUi->ClientRect()); + } + } + + +// ----------------------------------------------------------------------------- +// CountComponentControls +// ----------------------------------------------------------------------------- +// +TInt CEdtaAppView::CountComponentControls() const + { + return iEasyDialer ? 2 : 1; + } + + +// ----------------------------------------------------------------------------- +// ComponentControl +// ----------------------------------------------------------------------------- +// +CCoeControl* CEdtaAppView::ComponentControl(TInt aIndex) const + { + switch (aIndex) + { + case 0: return iScreenBuffer; + case 1: return iEasyDialer; // Can be null + default: return NULL; + } + } + +// ----------------------------------------------------------------------------- +// OfferKeyEventL +// ----------------------------------------------------------------------------- +// +TKeyResponse CEdtaAppView::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType ) + { + TKeyResponse handled = EKeyWasNotConsumed; + + if ( iEasyDialer ) + { + handled = iEasyDialer->OfferKeyEventL(aKeyEvent, aType); + } + + if ( handled == EKeyWasNotConsumed ) + { + handled = iScreenBuffer->OfferKeyEventL(aKeyEvent, aType); + } + else + { + handled = EKeyWasConsumed; + } + + return handled; + } + +// ----------------------------------------------------------------------------- +// GetScreenBuffer +// Returns the pointer to the screen buffer of the view. +// ----------------------------------------------------------------------------- +// +CEdtaScreenTextBuffer* CEdtaAppView::GetScreenBuffer() + { + return iScreenBuffer; + } + + +// ----------------------------------------------------------------------------- +// GetEasyDialer +// Returns the pointer to the easy dialer. +// ----------------------------------------------------------------------------- +// +CDialingExtensionInterface* CEdtaAppView::GetEasyDialer() + { + return iEasyDialer; + } + + + +// ----------------------------------------------------------------------------- +// InitContactDataStoreUrisL +// Initialises user contact data store URIs into field iContactDataStores. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::InitContactDataStoreUrisL() + { + HBufC* default_cdb = VPbkContactStoreUris::DefaultCntDbUri().AllocLC(); + User::LeaveIfError(iContactDataStores.Append( default_cdb )); + CleanupStack::Pop( default_cdb ); + + iContactStoreUriArray = CVPbkContactStoreUriArray::NewL(); + iContactStoreUriArray->AppendL(TVPbkContactStoreUriPtr( VPbkContactStoreUris::DefaultCntDbUri() )); + } + + +// ----------------------------------------------------------------------------- +// InitPredictiveContactSearchL +// Initialises predictive contact search. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::InitPredictiveContactSearchL() + { + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL enter")); + + iPredictiveContactSearchHandler = CPSRequestHandler::NewL(); + iPredictiveContactSearchHandler->AddObserverL(this); + + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL => CPSRequestHandler::NewL done")); + + InitContactDataStoreUrisL(); + + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL => InitContactDataStoreUrisL done")); + + iContactManager = CVPbkContactManager::NewL(*iContactStoreUriArray); + + // Put the searched contact fields into array. + RArray contact_fields; + CleanupClosePushL(contact_fields); + + // All supported fields are searched. The supported fiels are specified in cenrep private\10202BE9\2000B5C6. + contact_fields.Append(R_VPBK_FIELD_TYPE_FIRSTNAME); + contact_fields.Append(R_VPBK_FIELD_TYPE_LASTNAME); + contact_fields.Append(R_VPBK_FIELD_TYPE_COMPANYNAME); + contact_fields.Append(R_VPBK_FIELD_TYPE_EMAILHOME); + contact_fields.Append(R_VPBK_FIELD_TYPE_EMAILWORK); + contact_fields.Append(R_VPBK_FIELD_TYPE_EMAILGEN); + + // Create and fill ps settings object. + CPsSettings* ps_settings = CPsSettings::NewL(); + CleanupStack::PushL(ps_settings); + + ps_settings->SetSearchUrisL(iContactDataStores); + ps_settings->SetMaxResults(KEdtaMaximumMatchingCount); + ps_settings->SetSortType(EAlphabetical); + ps_settings->SetDisplayFieldsL(contact_fields); + + // Set the ps settings. + iPredictiveContactSearchHandler->SetSearchSettingsL(*ps_settings); + + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL => CPSRequestHandler::SetSearchSettingsL done")); + + CleanupStack::PopAndDestroy(ps_settings); + CleanupStack::PopAndDestroy(&contact_fields); + + iPredictiveSearchQuery = CPsQuery::NewL(); + + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL => CPsQuery::NewL done")); + + DebugPrintF(_L("CEdtaAppView::InitPredictiveContactSearchL exit")); + } + + +// ----------------------------------------------------------------------------- +// void ShowMatchingContacts(const TDesC& aSearchString) +// Starts an asynchronous search for contacts matching to aSearchString. +// The actual displaying of contact is done in callback HandlePsResultsUpdate +// - Hardcode to use ITU keyboard parameters +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::ShowMatchingContactsL(const TDesC& aSearchString) + { + DebugPrintF(_L("CEdtaAppView::ShowMatchingContactsL: enter '%S'"), &aSearchString ); + + iPredictiveSearchQuery->Reset(); + + for(TInt i = 0; i < aSearchString.Length() ;i++) + { + // Add a query item + CPsQueryItem* item = CPsQueryItem::NewL(); + CleanupStack::PushL(item); + + item->SetCharacter( aSearchString[i] ); + item->SetMode( EItut ); + iPredictiveSearchQuery->AppendL(*item); + + // Previous CPsQuery::AppendL takes the ownership of item. + // Do not delete item. + CleanupStack::Pop(item); + } + + // Issue the search. SearchL is asynchronous function => returns immediately. + iPredictiveContactSearchHandler->SearchL(*iPredictiveSearchQuery); + + DebugPrintF(_L("CEdtaAppView::ShowMatchingContactsL: exit")); + } + + +// ----------------------------------------------------------------------------- +// ShowNameOrderL +// Check the name ordering from phonebook engine by using phonebook engine API. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::ShowNameOrderL() + { + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: enter")); + + CPbkContactEngine* pbkEngine = CPbkContactEngine::NewL(); + CPbkContactEngine::TPbkNameOrder nameOrder = pbkEngine->NameDisplayOrderL(); + + iScreenBuffer->WriteLineL(_L("Phonebook name order is")); + switch ( nameOrder ) + { + case CPbkContactEngine::EPbkNameOrderLastNameFirstName: + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: The name order is: %d == LastName -> FirstName"), nameOrder ); + iScreenBuffer->WriteLineL(_L("* Last name, first name")); + break; + case CPbkContactEngine::EPbkNameOrderFirstNameLastName: + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: The name order is: %d == FirstName -> LastName"), nameOrder ); + iScreenBuffer->WriteLineL(_L("* First name, last name")); + break; + case CPbkContactEngine::EPbkNameOrderNotDefined: + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: The name order is: %d == Not defined"), nameOrder ); + iScreenBuffer->WriteLineL(_L("* Not defined")); + break; + default: + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: The name order is: %d == Unknown"), nameOrder ); + iScreenBuffer->WriteLineL(_L("* Unknown value: %d"), nameOrder ); + } + + delete pbkEngine; + + DebugPrintF(_L("CEdtaAppView::ShowNameOrderL: exit")); + } + +// ----------------------------------------------------------------------------- +// IsPCSServerLoaded +// Checks if the PCSServer is loaded properly at constructor +// ----------------------------------------------------------------------------- +// +TBool CEdtaAppView::IsPCSServerLoaded() + { + if( !iPredictiveSearchQuery ) + { + DebugPrintF(_L("CEdtaAppView::CheckPCSServerL: PCS server not loaded properly!")); + + TBuf tempStr; + tempStr.Copy(_L("PCS server not loaded!"));; + + TRAP_IGNORE( + { + CAknErrorNote* myNote = new (ELeave) CAknErrorNote(); + myNote->SetTimeout( CAknNoteDialog::ELongTimeout ); + TRAP_IGNORE( myNote->ExecuteLD( tempStr ) ); + } + ); + return EFalse; + } + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CheckPCSServerL +// Checks the configuration of the PCSServer and prints the sortorder of fields. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::CheckPCSServerL() + { + RArray field_order; + CleanupClosePushL(field_order); + + HBufC* default_cdb = VPbkContactStoreUris::DefaultCntDbUri().AllocLC(); + + _LIT(KEdtaField, "*"); + TBuf line(KEdtaField); + + iPredictiveContactSearchHandler->GetDataOrderL(*default_cdb, field_order); + + DebugPrintF(_L("CEdtaAppView::ShowContactFieldOrderL: Number of fields: %d"), field_order.Count() ); + + TInt requiredFieldsCount = 3; + + for ( TInt i = 0; i < field_order.Count(); i++) + { + line.Append((TChar) ' '); + line.AppendNum(field_order[i]); + + if(( field_order[i] == R_VPBK_FIELD_TYPE_FIRSTNAME) || + ( field_order[i] == R_VPBK_FIELD_TYPE_LASTNAME) || + ( field_order[i] == R_VPBK_FIELD_TYPE_COMPANYNAME )) + { + requiredFieldsCount--; + } + } + + CleanupStack::PopAndDestroy( default_cdb ); + CleanupStack::PopAndDestroy( &field_order ); + + iScreenBuffer->WriteLineL(_L("PCS server fields:")); + iScreenBuffer->WriteLineL(line); + + DebugPrintF(_L("CEdtaAppView::ShowContactFieldOrderL: '%S'"), &line ); + + if( requiredFieldsCount == 0 ) + { + DebugPrintF(_L("CEdtaAppView::ShowContactFieldOrderL: All required fields found from PCSServer, configuration is OK")); + iScreenBuffer->WriteLineL(_L("* All required fields found")); + } + else + { + DebugPrintF(_L("CEdtaAppView::ShowContactFieldOrderL: Not all required fields found from PCSServer, configuration is wrong")); + iScreenBuffer->WriteLineL(_L("* PCS server misconfigured!")); + iScreenBuffer->WriteLineL(_L("* Easydialing may not")); + iScreenBuffer->WriteLineL(_L("* match your queries!")); + } + } + + +// ----------------------------------------------------------------------------- +// void LaunchNthContactL(TInt aIx) +// Launches communication launcher for the first contact in the previous +// search. If not contacts found or no search yet done, function does nothing. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::LaunchNthContactL(TInt aIx) + { + if (aIx < 0 || iMatchingContactLinks.Count() <= aIx) + { + DebugPrintF(_L("CEdtaAppView::LaunchNthContactL: No contacts retrieved yet") ); + return; + } + + DebugPrintF(_L("CEdtaAppView::LaunchNthContactL: enter, index: %d, setting parameters.."), aIx ); + + MCCAParameter* launch_parameters = TCCAFactory::NewParameterL(); + CleanupClosePushL( *launch_parameters ); + + launch_parameters->SetConnectionFlag(MCCAParameter::ENormal); + launch_parameters->SetContactDataFlag(MCCAParameter::EContactLink); + + // Pack the contact link and expand it to 16-bit descriptor. + HBufC8* contact8 = iMatchingContactLinks[aIx]->PackLC(); + HBufC16* contact16 = HBufC16::NewLC( contact8->Length() ); + contact16->Des().Copy( contact8->Des() ); + + launch_parameters->SetContactDataL( contact16->Des() ); + + CleanupStack::PopAndDestroy( contact16 ); + CleanupStack::PopAndDestroy( contact8 ); + + DebugPrintF(_L("CEdtaAppView::LaunchNthContactL: launching CCA..")); + + iContactLauncher->LaunchAppL( *launch_parameters, this ); + + // Ownership of parameter transferred to CCA launcher => pop but do not destroy. + CleanupStack::Pop(launch_parameters); // Close parameter + + DebugPrintF(_L("CEdtaAppView::LaunchNthContactL: exit")); + } + + + +// ----------------------------------------------------------------------------- +// void DoMiscellaneousTestsL() +// Does various tests on easy dialing that are difficult to do through normal +// testing. Mainly for coverage testing purposes. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::DoMiscellaneousTestsL() + { + // Coverage tests for observer handling. + iEasyDialer->AddObserverL( iDummyListener ); + iEasyDialer->AddObserverL( NULL ); + iEasyDialer->RemoveObserver( iDummyListener ); + } + +// ----------------------------------------------------------------------------- +// void HandlePsResultsUpdate(RPointerArray& aResult, RPointerArray& aSeqs) +// Searched matching contacts using PCS and shows them on the screen. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::HandlePsResultsUpdate(RPointerArray& aResults, RPointerArray& aSeqs) + { + TRAP_IGNORE( HandlePredictiveSearchResultL(aResults, aSeqs) ); + } + + +// ----------------------------------------------------------------------------- +// void HandlePsError(TInt aErrorCode) +// Called when search error happens. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::HandlePsError(TInt aErrorCode) + { + DebugPrintF(_L("CEdtaAppView::HandlePsError: %d"), aErrorCode ); + + _LIT(KEdtaCachingError, "*** Caching error %d ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingError, aErrorCode) ); + + } + + +// ----------------------------------------------------------------------------- +// void CachingStatus(TCachingStatus& aStatus, TInt& aError) +// Called to update caching status. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::CachingStatus(TCachingStatus& aStatus, TInt& aError ) + { + DebugPrintF(_L("CEdtaAppView::CachingStatus: %d"), aError); + + switch (aStatus) + { + case ECachingNotStarted: + { + _LIT(KEdtaCachingStatusStarted, "*** Caching started ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingStatusStarted) ); + } + break; + case ECachingInProgress: + { + _LIT(KEdtaCachingStatusInProgress, "*** Caching in progress ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingStatusInProgress) ); + } + break; + case ECachingComplete: + { + _LIT(KEdtaCachingStatusComplete, "*** Caching complete ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingStatusComplete) ); + } + break; + case ECachingCompleteWithErrors: + { + _LIT(KEdtaCachingStatusCompleteWithErrors, "*** Caching complete with error %d ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingStatusCompleteWithErrors, aError) ); + } + break; + default: + { + _LIT(KEdtaCachingStatusUnknown, "*** Unknown caching status %d ***"); + TRAP_IGNORE( iScreenBuffer->WriteLineL(KEdtaCachingStatusUnknown, (TInt) aStatus) ); + } + break; + } + } + + + +// ----------------------------------------------------------------------------- +// void HandlePredictiveSearchResultL(RPointerArray& aResult, RPointerArray& aSeqs) +// Handles predictive search results. A leaving version to be trapped in HandlePsResultsUpdate. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::HandlePredictiveSearchResultL(RPointerArray& aResults, RPointerArray& /* aSeqs */) + { + TInt results = aResults.Count(); + DebugPrintF(_L("CEdtaAppView::HandlePredictiveSearchResultL enter, matching contacts found: %d"), results ); + + iContactNames.ResetAndDestroy(); + iMatchingContactLinks.ResetAndDestroy(); + + // map results to old contact match data + for (TInt i = 0; i < aResults.Count(); i ++) + { + TBuf temp; + _LIT(KEdtaContactFormatString, "%S %S"); + + // Store each contact name into iContactNames. + temp.Format(KEdtaContactFormatString, aResults[i]->Data(0), aResults[i]->Data(1)); + + DebugPrintF(_L("CEdtaAppView::HandlePredictiveSearchResultL: Contact #%d: '%S'"), i+1, &temp ); + + HBufC* contact_name = HBufC::NewL(temp.Length()); + *contact_name = temp; + iContactNames.Append( contact_name ); + + + // Each contact link stored to iMatchingContactLinks, to be possible used later by + // CCA launcher functions. + MVPbkContactLink* link = iPredictiveContactSearchHandler->ConvertToVpbkLinkLC(*(aResults[i]), *iContactManager); + iMatchingContactLinks.Append( link ); + CleanupStack::Pop( link ); + + // Write the contact name to screen buffer + iScreenBuffer->WriteLineL( *contact_name ); + + TUint8 match_mask = aResults[i]->FieldMatch(); + + // Show other search fields only if search matches them. + if (match_mask & (1 << KEdtaContactCompanyIndex)) + { + _LIT(KEdtaContactCompany, "* Company: %S"); + iScreenBuffer->WriteLineL(KEdtaContactCompany, aResults[i]->Data(KEdtaContactCompanyIndex)); + } + if (match_mask & (1 << KEdtaContactEmailHomeIndex)) + { + _LIT(KEdtaContactEmailHome, "* Home e-mail: %S"); + iScreenBuffer->WriteLineL(KEdtaContactEmailHome, aResults[i]->Data(KEdtaContactEmailHomeIndex)); + } + if (match_mask & (1 << KEdtaContactEmailWorkIndex)) + { + _LIT(KEdtaContactEmailWork, "* Work e-mail: %S"); + iScreenBuffer->WriteLineL(KEdtaContactEmailWork, aResults[i]->Data(KEdtaContactEmailWorkIndex)); + } + if (match_mask & (1 << KEdtaContactEmailGenIndex)) + { + _LIT(KEdtaContactEmailGen, "* E-mail: %S"); + iScreenBuffer->WriteLineL(KEdtaContactEmailGen, aResults[i]->Data(KEdtaContactEmailGenIndex)); + } + } + _LIT(KEdtaNumberOfMatchingContacts, "*** %d contacts found! ***"); + iScreenBuffer->WriteLineL(KEdtaNumberOfMatchingContacts, aResults.Count()); + + DebugPrintF(_L("CEdtaAppView::HandlePredictiveSearchResultL exit")); + } + + +// ----------------------------------------------------------------------------- +// HandleDialingExtensionEvent +// +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::HandleDialingExtensionEvent( MDialingExtensionObserver::TEvent aEvent ) + { + DebugPrintF(_L("CEdtaAppView::HandleDialingExtensionEvent")); + + if ( aEvent == MDialingExtensionObserver::EFocusChanged ) + { + if ( iEasyDialer->IsFocused() ) + { + iScreenBuffer->SetFocus( EFalse, EDrawNow ); + } + else + { + iScreenBuffer->SetFocus( ETrue, EDrawNow ); + } + } + } + + +// ----------------------------------------------------------------------------- +// SelectAndLaunchContactL +// Shows a list box, the launches CCA launcher for user selected contact. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::SelectAndLaunchContactL() + { + DebugPrintF(_L("CEdtaAppView::SelectAndLaunchContactL enter")); + + // Create list of matched contacts and show them on the screen + + CAknSingleHeadingPopupMenuStyleListBox* listBox = new(ELeave) CAknSingleHeadingPopupMenuStyleListBox; + CleanupStack::PushL( listBox ); + + CAknPopupList* popupList = CAknPopupList::NewL( listBox, + R_AVKON_SOFTKEYS_SELECT_CANCEL, + AknPopupLayouts::EMenuGraphicHeadingWindow ); + CleanupStack::PushL( popupList ); + + listBox->ConstructL( popupList, EAknListBoxSelectionList ); + listBox->CreateScrollBarFrameL( ETrue ); + listBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, + CEikScrollBarFrame::EAuto ); + + _LIT( KMatchedContacts, "Matched contacts:" ); + popupList->SetTitleL( KMatchedContacts ); + + // Add items into list + + CDesCArrayFlat* itemArray = new(ELeave)CDesCArrayFlat(KEdtaListBoxGranularity); + CleanupStack::PushL(itemArray); + + _LIT( KListItemSeparator1, ". \t" ); + + for (TInt listIndex = 0; listIndex < iContactNames.Count(); listIndex++ ) + { + TBuf itemString; + itemString.Zero(); + itemString.AppendNum( listIndex+1 ); + itemString.Append( KListItemSeparator1 ); + itemString.Append( *iContactNames[listIndex] ); + + itemArray->AppendL(itemString); + } + + CTextListBoxModel* model = listBox->Model(); + model->SetItemTextArray( itemArray ); + model->SetOwnershipType( ELbmOwnsItemArray ); + CleanupStack::Pop( itemArray ); // Pop itemArray - the listBox model owns this now + + if( popupList->ExecuteLD() ) // Show the list finally + { + if( listBox->CurrentItemIndex() >= 0 ) + { + // Launch communication launcher for selected contact + LaunchNthContactL( listBox->CurrentItemIndex() ); + } + } + + CleanupStack::Pop( popupList ); + CleanupStack::PopAndDestroy( listBox ); + + DebugPrintF(_L("CEdtaAppView::SelectAndLaunchContactL exit")); + } + + +// ----------------------------------------------------------------------------- +// CCASimpleNotifyL +// Implements MCCAObserver notification interface. +// Nothing better to do but show the parameters. +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::CCASimpleNotifyL( TNotifyType aType, TInt aReason ) + { + DebugPrintF(_L("CEdtaAppView::CCASimpleNotifyL: aType: %d, aReason: %d"), (TInt)aType, aReason ); + + _LIT(KEdtaCCAExitReason, "Launcher exit reason %d, %d"); + iScreenBuffer->WriteLineL(KEdtaCCAExitReason, aType, aReason); + } + + +// ----------------------------------------------------------------------------- +// LoadPluginL +// Load the easydialing ECOM plugin +// ----------------------------------------------------------------------------- +// +void CEdtaAppView::LoadPluginL() + { + TRAPD( error, + { + iEasyDialer = CDialingExtensionInterface::NewL(); + iEasyDialer->InitializeL( *this ); + } ); + + if( error ) + { + DebugPrintF(_L("CEdtaAppView::LoadPluginL FAIL, error: %d"), error ); + iScreenBuffer->WriteLineL(_L("* EasyDialing Plugin load fail: %d"), error ); + iEasyDialer = NULL; + } + else + { + iScreenBuffer->WriteLineL(_L("EasyDialing Plugin loaded")); + DebugPrintF(_L("CEdtaAppView::LoadPluginL OK" )); + } + } + +// End of File +