/*
* Copyright (c) 2005-2007 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: Phonebook 2 Predictive search view stack
*
*/
#include "CPbk2ContactPositionInfo.h"
#include "cpbk2predictiveviewstack.h"
// Phonebook 2 / Virtual Phonebook
#include <MVPbkContactViewFiltering.h>
#include <CVPbkContactFindPolicy.h>
#include <VPbkEng.rsg>
#include <MVPbkViewContact.h>
#include <CVPbkContactIdConverter.h>
#include <MPbk2AppUi.h>
#include <MPbk2ApplicationServices.h>
#include <VPbkContactStoreUris.h>
#include <centralrepository.h>
#include <Phonebook2PrivateCRKeys.h>
#include <CVPbkTopContactManager.h>
#include "cpbk2filteredviewstack.h"
#include <CPbk2StoreConfiguration.h>
#include <MVPbkContactBookmarkCollection.h>
#include <CVPbkContactIdConverter.h>
#include "CPbk2PredictiveSearchFilter.h"
#include <MPbk2ContactNameFormatter.h>
#include <MPbk2ContactNameFormatter2.h>
// Predictive seard engine headers
#include <CPsSettings.h>
#include <CPsQueryItem.h>
#include <CPsData.h>
#include <CPsRequestHandler.h>
// Debugging headers
#include <Pbk2Debug.h>
#include <bidivisual.h>
#include <fepbase.h>
#include "Phonebook2PrivateCRKeys.h"
// System includes
#include <aknsfld.h>
#include <featmgr.h>
// CONSTANTS
const TInt Kspace = ' ';
_LIT(KPsGroupDBSuffix, "?id=%d");
/// Unnamed namespace for local definitions
namespace {
// --------------------------------------------------------------------------
// SendEventToObservers
// Sends events to the array of observes that take MVPbkContactViewBase.
// as a parameter.
//
// @param aView The parameter for the NotifyFunc.
// @param aObservers An array of MVPbkContactViewObservers.
// @param aNotifyFunc A member function pointer of the
// MVPbkContactViewObserver.
// --------------------------------------------------------------------------
//
template <class Observer, class NotifyFunc>
void SendEventToObservers( MVPbkContactViewBase& aView,
RPointerArray<Observer>& aObservers,
NotifyFunc aNotifyFunc )
{
const TInt count = aObservers.Count();
for (TInt i = count-1; i >= 0 ; --i)
{
Observer* observer = aObservers[i];
(observer->*aNotifyFunc)(aView);
}
}
// --------------------------------------------------------------------------
// SendEventToObservers
// Sends events to the array of MVPbkContactViewObserver.
// Used for MVPbkContactViewObserver functions that have two extra parameters
// in addition to MVPbkContactViewBase.
//
// @param aView The first parameter for the NotifyFunc.
// @param aObservers An array of MVPbkContactViewObserver.
// @param aNotifyFunc A member function pointer of the
// MVPbkContactViewObserver.
// @param aParam1 The second parameter for the aNotifyFunc.
// @param aParam2 The third parameter for the aNotifyFunc.
// --------------------------------------------------------------------------
//
template <class Observer, class FuncPtr, class ParamType1, class ParamType2>
void SendEventToObservers( MVPbkContactViewBase& aView,
RPointerArray<Observer>& aObservers,
FuncPtr aNotifyFunc,
ParamType1 aParam1, ParamType2& aParam2)
{
const TInt count = aObservers.Count();
for (TInt i = count-1; i >= 0 ; --i)
{
Observer* observer = aObservers[i];
(observer->*aNotifyFunc)(aView, aParam1, aParam2);
}
}
} /// namespace
TInt CPbk2ContactPositionInfo::CompareByPosition(
const CPbk2ContactPositionInfo& aFirst,
const CPbk2ContactPositionInfo& aSecond )
{
if( aFirst.iPos < aSecond.iPos )
{
return -1;
}
else if( aFirst.iPos == aSecond.iPos )
{
return 0;
}
else
{
return 1;
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CPbk2PredictiveViewStack
// --------------------------------------------------------------------------
CPbk2PredictiveViewStack::CPbk2PredictiveViewStack( CPbk2PredictiveSearchFilter& aSearchFilter,
MPbk2ContactNameFormatter& aNameformatter ):
CActive( EPriorityStandard ), iSearchFilter( aSearchFilter ),
iNameformatter(aNameformatter),
iNonMatchedMarkedContactStartIndex(KErrNotFound),
iNonMatchedMarkedContactEndIndex(KErrNotFound)
{
CActiveScheduler::Add( this );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::~CPbk2PredictiveViewStack
// --------------------------------------------------------------------------
//
CPbk2PredictiveViewStack::~CPbk2PredictiveViewStack()
{
Cancel();
iBidiPatterns.ResetAndDestroy();
iPatternsCollection.ResetAndDestroy();
iStackObservers.Reset();
iViewObservers.Reset();
delete iConverterDefaultStore;
delete iPsQuery;
delete iPsHandler;
delete iCurrentGroupLink;
if ( iBaseView )
{
iBaseView->RemoveObserver( *this );
}
if( iPredictiveSearchResultContactLinkArrray )
{
iPredictiveSearchResultContactLinkArrray->ResetAndDestroy();
delete iPredictiveSearchResultContactLinkArrray;
}
iTopContactPositionInfoArray.ResetAndDestroy();
iMarkedContactsPositionInfoArray.ResetAndDestroy();
delete iTopContactManager;
iSearchText.Close();
if(iFeatureManagerInitilized)
{
FeatureManager::UnInitializeLib();
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::NewL
// --------------------------------------------------------------------------
//
CPbk2PredictiveViewStack* CPbk2PredictiveViewStack::NewL(
MVPbkContactViewBase& aBaseView,
CPbk2PredictiveSearchFilter& aSearchFilter,
MPbk2ContactNameFormatter& aNameformatter )
{
CPbk2PredictiveViewStack* self = new ( ELeave ) CPbk2PredictiveViewStack( aSearchFilter,
aNameformatter );
CleanupStack::PushL( self );
self->ConstructL( aBaseView );
CleanupStack::Pop( self );
return self;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ConstructL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ConstructL( MVPbkContactViewBase& aBaseView )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::ConstructL"));
iSearchedState = EFalse;
iViewReady = EFalse;
iBaseView = &aBaseView;
// Initialize feature manager
FeatureManager::InitializeLibL();
iFeatureManagerInitilized = ETrue;
// Initilize the PCS engine
InitializePCSEngineL();
CVPbkContactManager& manager = Phonebook2::Pbk2AppUi()->
ApplicationServices().ContactManager();
iTopContactManager = CVPbkTopContactManager::NewL( manager );
// Arrary for holding the search result links
iPredictiveSearchResultContactLinkArrray = CVPbkContactLinkArray::NewL();
// Start listening view events
iBaseView->AddObserverL( *this );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::UpdateFilterL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::UpdateFilterL( const MDesCArray& aFindStrings,
const MVPbkContactBookmarkCollection* aAlwaysincluded,
TBool aAlwaysIncludedChanged )
{
if ( aAlwaysIncludedChanged )
{
// iBookMarkCollection is not owned
iBookMarkCollection =
const_cast<MVPbkContactBookmarkCollection*>( aAlwaysincluded );
}
iPredictiveSearch = iSearchFilter.IsPredictiveActivated();
TKeyboardModes pcsKeyboardMode( EItut );
if ( iPredictiveSearch )
{
pcsKeyboardMode = EItut;
}
else
{
pcsKeyboardMode = EQwerty;
}
// During filtering if there were multitaps, Fep transacton is broken
// and search box sends canceletion of last tap, we ignore this.
if( iPredictiveSearch && iSearchFilter.IsFiltering() )
{
return;
}
RBuf searchText;
iSearchFilter.GetSearchTextL( searchText );
CleanupClosePushL( searchText );
// Events go on up and down key, it is not good do search always twice
TInt compareSearchText = iSearchText.Compare(searchText);
iSearchText.Close();
iSearchText.CreateL(searchText.Length());
iSearchText = searchText;
CleanupStack::PopAndDestroy(&searchText);
if( compareSearchText == 0 )
{
return;
}
if( !aFindStrings.MdcaCount() )
{
if( compareSearchText == 1 )
{
if( !iSearchText.Length() )
{
Reset();
}
else
{
ClearSearch();
}
}
return;
}
// Delete the previous query
delete iPsQuery;
iPsQuery = NULL;
// Create the new search query
iPsQuery = CPsQuery::NewL();
// Combine the search strings and create the PCS query
for ( TInt j = 0; j < aFindStrings.MdcaCount(); j++ )
{
HBufC* searchString = aFindStrings.MdcaPoint(j).AllocL();
TPtrC searchStringPtr(*searchString);
CleanupStack::PushL( searchString );
for ( TInt i = 0; i < searchStringPtr.Length(); i++ )
{
// Add a query item
CPsQueryItem* item = CPsQueryItem::NewL();
item->SetCharacter(searchStringPtr[i]);
TInt qwertyNumber = KErrCancel;
if( iPredictiveSearch )
{
TLex numberVal( searchStringPtr.Mid(i, 1) );
TInt num = 0;
qwertyNumber = numberVal.Val(num);
}
if( qwertyNumber == KErrNone )
{
// Set qwerty search mode (in predictive search we can tap numbers only by long tap)
item->SetMode( EQwerty );
}
else
{
// Set current search mode
item->SetMode( pcsKeyboardMode );
}
iPsQuery->AppendL(*item);
}
//Add a space in between two words
if(aFindStrings.MdcaCount() > 1)
{
CPsQueryItem* item = CPsQueryItem::NewL();
item->SetCharacter(Kspace);
item->SetMode(EItut);
iPsQuery->AppendL(*item);
}
//Cleanup
CleanupStack::PopAndDestroy( searchString);
}
//Send the search query to the PCS engine
iPsHandler->SearchL(*iPsQuery);
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::Reset
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::Reset()
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::Reset: topview(0x%x), current stack level = %d"));
TRAP_IGNORE(iSearchFilter.ResetL());
iPsHandler->CancelSearch();
ClearSearch();
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ClearSearch
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ClearSearch()
{
iNonMatchedMarkedContactStartIndex = KErrNotFound;
iNonMatchedMarkedContactEndIndex = KErrNotFound;
iSearchedState = EFalse;
iPredictiveSearchResultContactLinkArrray->ResetAndDestroy();
iTopContactPositionInfoArray.ResetAndDestroy();
iSearchText.Close();
SendTopViewChangedEvent( *iBaseView );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::BaseView
// --------------------------------------------------------------------------
//
MVPbkContactViewBase& CPbk2PredictiveViewStack::BaseView() const
{
return *iBaseView;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SetNewBaseViewL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SetNewBaseViewL(
MVPbkContactViewBase& aBaseView )
{
Reset();
// Remove observering the old base view
if ( iBaseView )
{
iBaseView->RemoveObserver( *this );
}
iBaseView = &aBaseView;
// Start listening to new base view
iBaseView->AddObserverL( *this );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::Level
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::Level() const
{
if ( iSearchedState )
{
return 1;
}
return 0;
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::AddStackObserverL
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::AddStackObserverL(
MPbk2FilteredViewStackObserver& aStackObserver )
{
iStackObservers.AppendL( &aStackObserver );
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::RemoveStackObserver
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::RemoveStackObserver(
MPbk2FilteredViewStackObserver& aStackObserver )
{
TInt index = iStackObservers.Find( &aStackObserver );
if ( index != KErrNotFound )
{
iStackObservers.Remove( index );
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::Type
// --------------------------------------------------------------------------
//
TVPbkContactViewType CPbk2PredictiveViewStack::Type() const
{
return iBaseView->Type();
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ChangeSortOrderL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ChangeSortOrderL(
const MVPbkFieldTypeList& aSortOrder )
{
return iBaseView->ChangeSortOrderL( aSortOrder );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SortOrder
// --------------------------------------------------------------------------
//
const MVPbkFieldTypeList& CPbk2PredictiveViewStack::SortOrder() const
{
return iBaseView->SortOrder();
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::RefreshL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::RefreshL()
{
return iBaseView->RefreshL();
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactCountL
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::ContactCountL() const
{
TInt count;
if ( iSearchedState )
{
count = iPredictiveSearchResultContactLinkArrray->Count();
}
else
{
count = iBaseView->ContactCountL();
}
return count;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactAtL
// --------------------------------------------------------------------------
//
const MVPbkViewContact& CPbk2PredictiveViewStack::ContactAtL
( TInt aIndex ) const
{
TInt ret = BaseViewIndex( aIndex);
User::LeaveIfError( ret );
return iBaseView->ContactAtL( ret );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CreateLinkLC
// --------------------------------------------------------------------------
//
MVPbkContactLink* CPbk2PredictiveViewStack::CreateLinkLC( TInt aIndex ) const
{
TInt ret = BaseViewIndex( aIndex);
User::LeaveIfError( ret );
return iBaseView->CreateLinkLC( ret );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::IndexOfLinkL
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::IndexOfLinkL(
const MVPbkContactLink& aContactLink ) const
{
TInt ret = KErrNotFound;
if ( iSearchedState )
{
ret = iPredictiveSearchResultContactLinkArrray->Find( aContactLink );
}
else
{
// Just return the index in the baseview
ret = iBaseView->IndexOfLinkL( aContactLink );
}
return ret;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::AddObserverL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::AddObserverL
( MVPbkContactViewObserver& aObserver )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::AddObserverL - IN"));
if ( IsActive() )
{
Cancel();
}
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
SetActive();
// Events are sent in reverse order so insert to first position.
iViewObservers.InsertL( &aObserver, 0 );
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::AddObserverL - OUT"));
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::RemoveObserver
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::RemoveObserver(
MVPbkContactViewObserver& aObserver )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::RemoveObserver - IN"));
TInt index = iViewObservers.Find( &aObserver );
if ( index != KErrNotFound )
{
iViewObservers.Remove( index );
}
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::RemoveObserver - OUT"));
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::MatchContactStore
// --------------------------------------------------------------------------
//
TBool CPbk2PredictiveViewStack::MatchContactStore(
const TDesC& aContactStoreUri ) const
{
return iBaseView->MatchContactStore( aContactStoreUri );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::MatchContactStoreDomain
// --------------------------------------------------------------------------
//
TBool CPbk2PredictiveViewStack::MatchContactStoreDomain(
const TDesC& aContactStoreDomain ) const
{
return iBaseView->MatchContactStoreDomain( aContactStoreDomain );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CreateBookmarkLC
// --------------------------------------------------------------------------
//
MVPbkContactBookmark* CPbk2PredictiveViewStack::CreateBookmarkLC(
TInt aIndex ) const
{
return iBaseView->CreateBookmarkLC( BaseViewIndex( aIndex ) );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::IndexOfBookmarkL
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::IndexOfBookmarkL(
const MVPbkContactBookmark& aContactBookmark ) const
{
TInt ret = KErrNotFound;
if ( iSearchedState )
{
TInt indexInBaseView = iBaseView->IndexOfBookmarkL( aContactBookmark );
const MVPbkViewContact& contact = iBaseView->ContactAtL( indexInBaseView );
TInt countInSearchedResult = iPredictiveSearchResultContactLinkArrray->Count();
for ( TInt i = 0; i < countInSearchedResult && ret == KErrNotFound; i++ )
{
const MVPbkContactLink& link = iPredictiveSearchResultContactLinkArrray->At( i );
if ( link.RefersTo( contact ) )
{
ret = i;
}
}
}
else
{
ret = iBaseView->IndexOfBookmarkL( aContactBookmark );
}
return ret;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ViewFiltering
// --------------------------------------------------------------------------
//
MVPbkContactViewFiltering* CPbk2PredictiveViewStack::ViewFiltering()
{
// The stack itself doesn't support filtering
return NULL;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactViewReady
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ContactViewReady( MVPbkContactViewBase& /*aView*/ )
{
iViewReady = ETrue;
SendBaseViewChangedEvent();
SendEventToObservers( *this, iViewObservers,
MVPbkContactViewObserver::ContactViewReady );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactViewUnavailable
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ContactViewUnavailable(
MVPbkContactViewBase& /*aView*/ )
{
iViewReady = EFalse;
SendEventToObservers( *this, iViewObservers,
MVPbkContactViewObserver::ContactViewUnavailable );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactAddedToView
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ContactAddedToView
( MVPbkContactViewBase& aView, TInt aIndex,
const MVPbkContactLink& aContactLink )
{
// Reset since we need to return to base view
// when a new contact is added
Reset();
//Send observer events
if ( iBaseView == &aView )
{
SendEventToObservers( *this, iStackObservers,
MPbk2FilteredViewStackObserver::ContactAddedToBaseView, aIndex,
aContactLink );
// Always forward only top view events to clients
SendEventToObservers( *this, iViewObservers,
MVPbkContactViewObserver::ContactAddedToView, aIndex,
aContactLink );
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactRemovedFromView
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ContactRemovedFromView
( MVPbkContactViewBase& aView, TInt aIndex,
const MVPbkContactLink& aContactLink )
{
TRAP_IGNORE ( HandleContactDeletionL( aView, aIndex,aContactLink ) )
//Send observer events
if ( iBaseView == &aView )
{
// Always forward top view events to clients
SendEventToObservers( *this, iViewObservers,
MVPbkContactViewObserver::ContactRemovedFromView, aIndex,
aContactLink );
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::ContactViewError
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::ContactViewError
( MVPbkContactViewBase& aView, TInt aError, TBool aErrorNotified )
{
iViewReady = EFalse;
//Send observer events
if ( iBaseView == &aView )
{
// Always forward only top view events to clients
SendEventToObservers( *this, iViewObservers,
MVPbkContactViewObserver::ContactViewError, aError,
aErrorNotified );
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::HandlePsResultsUpdate
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::HandlePsResultsUpdate(
RPointerArray<CPsClientData>& aSearchResults,
RPointerArray<CPsPattern>& searchSeqs )
{
//set the searched state to indicate that
// predictive search view is now active
iSearchedState = ETrue;
// update pattern array
TRAP_IGNORE( CreatePatternsL(searchSeqs) );
//Clean up the data stored during previous search
iPredictiveSearchResultContactLinkArrray->ResetAndDestroy();
iTopContactPositionInfoArray.ResetAndDestroy();
//Calculate the search result indexes
TRAPD( err, CalculateSearchResultIndexesL( aSearchResults ) );
if ( err != KErrNone )
{
Reset();
}
else
{
if ( !aSearchResults.Count() )
{
TRAP_IGNORE( SendPSNoResultsEventL() );
}
}
SendTopViewChangedEvent( *this );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::HandlePsError
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::HandlePsError( TInt /*aErrorCode*/ )
{
Reset();
TRAP_IGNORE( InitializePCSEngineL() );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CachingStatus
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::CachingStatus( TCachingStatus& /*aStatus*/,
TInt& /*aError*/)
{
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::RunL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::RunL()
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::RunL - IN"));
if ( iViewReady )
{
iViewObservers[0]->ContactViewReady( *this );
}
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING(
"CPbk2PredictiveViewStack::RunL - OUT"));
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::DoCancel
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::DoCancel()
{
// Nothing to cancel
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::RunError
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::RunError( TInt aError )
{
iViewObservers[0]->ContactViewError( *this, aError, ETrue );
return KErrNone;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CalculateSearchResultIndexesL
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::CalculateSearchResultIndexesL(
RPointerArray<CPsClientData>& aSearchResults )
{
__ASSERT_ALWAYS( iTopContactManager, User::Leave( KErrGeneral ) );
//Holds the Matched Char Seq of the First Item in the
//Nameslist View w.r.t the initiated Predictive Search
TBuf<KSearchFieldLength> matchSeqChr;
CVPbkContactManager& cntManager = Phonebook2::Pbk2AppUi()->
ApplicationServices().ContactManager();
const TInt resultCount = aSearchResults.Count();
for( TInt n = 0 ; n < resultCount ; ++n )
{
// Store the view index of search results
CPsClientData* result = aSearchResults[n];
MVPbkContactLink* contactLink = iPsHandler->ConvertToVpbkLinkLC(*result,cntManager);
//Get the index in the base view
// We need to check if base view contains this contact
TInt posInBaseView = iBaseView->IndexOfLinkL( *contactLink );
if ( posInBaseView != KErrNotFound )
{
const MVPbkViewContact& contact = iBaseView->ContactAtL( posInBaseView );
TBuf< KPsQueryMaxLen > result;
iSearchFilter.LookupL( contact, *this, iNameformatter, result );
if( result.Length() <= 0 )
{
CleanupStack::Pop(); //contactLink
continue;
}
TBool topcontact = iTopContactManager->IsTopContact( contact );
if ( topcontact )
{
// ownership of contactLink is transfered, CPbk2TopContactPositionInfo
// also keeps the contactLink' position from iBaseView
CPbk2ContactPositionInfo* topContactPosInfo =
CPbk2ContactPositionInfo::NewLC( contactLink, posInBaseView );
iTopContactPositionInfoArray.AppendL( topContactPosInfo );
CleanupStack::Pop( topContactPosInfo );
}
else
{
iPredictiveSearchResultContactLinkArrray->AppendL( contactLink );
}
CleanupStack::Pop(); //contactLink
}
else
{
CleanupStack::PopAndDestroy(); //contactLink
}
}
iNonMatchedMarkedContactStartIndex = KErrNotFound;
iNonMatchedMarkedContactEndIndex = KErrNotFound;
//save marked contacts info to iMarkedContactsPositionInfoArray
if ( iBookMarkCollection )
{
SaveBookmarkContatsInfoL();
SortbyPositionInMainView( iMarkedContactsPositionInfoArray );
iNonMatchedMarkedContactStartIndex = 0;
iNonMatchedMarkedContactEndIndex = iMarkedContactsPositionInfoArray.Count() - 1;
MoveArrayToSearchedResultTopL( iMarkedContactsPositionInfoArray );
}
// add those top contacts to top of the iPredictiveSearchResultContactLinkArrray,
// the order follows top contact orders in name list
SortbyPositionInMainView( iTopContactPositionInfoArray );
if ( iNonMatchedMarkedContactStartIndex != KErrNotFound )
{
iNonMatchedMarkedContactStartIndex += iTopContactPositionInfoArray.Count();
iNonMatchedMarkedContactEndIndex += iTopContactPositionInfoArray.Count();
}
MoveArrayToSearchedResultTopL( iTopContactPositionInfoArray );
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::InitializePCSEngineL
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::InitializePCSEngineL()
{
if(iPsHandler)
{
delete iPsHandler;
iPsHandler = NULL;
}
// Create async request handle for predictive search engine
iPsHandler = CPSRequestHandler::NewL();
iPsHandler->AddObserverL( this );
// If the iCurrentGroupLink is set, then no need to re-do the settings.It is already done.
if(iCurrentGroupLink)
{
return;
}
RPointerArray<TDesC> databases;
if ( iBaseView->MatchContactStore( VPbkContactStoreUris::SimGlobalFdnUri() ) )
{
//FDN view, initialize PS with FDN contacts only
databases.AppendL(VPbkContactStoreUris::SimGlobalFdnUri().AllocL());
}
else
{
CPbk2StoreConfiguration& config = Phonebook2::Pbk2AppUi()->ApplicationServices().StoreConfiguration();
CVPbkContactStoreUriArray* stores = config.SearchStoreConfigurationL();
CleanupStack::PushL(stores);
TInt count = stores->Count();
for ( TInt i = 0; i < count; ++i)
{
TVPbkContactStoreUriPtr uriPtr = stores->operator[](i);
databases.AppendL(uriPtr.UriDes().AllocL());
}
CleanupStack::PopAndDestroy(); //stores
}
SetPsSettingL(databases);
databases.ResetAndDestroy();
}
// --------------------------------------------------------------------------
// Maps from the search subset position index to base view index.
// @param aSearchResultIndex Index within scope of search result set.
// @return Index of the contact in base view.
// --------------------------------------------------------------------------
TInt CPbk2PredictiveViewStack::BaseViewIndex( TInt aSearchResultIndex ) const
{
// If search is not active, the argument is actually already a base view index.
TInt index = aSearchResultIndex;
if ( iSearchedState )
{
TRAP_IGNORE( index =
iBaseView->IndexOfLinkL(
iPredictiveSearchResultContactLinkArrray->At( aSearchResultIndex ) ) );
}
return index;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::HandleContactDeletionL
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::HandleContactDeletionL( MVPbkContactViewBase& /*aView*/,
TInt /*aIndex*/, const MVPbkContactLink& aContactLink )
{
TInt removedContactPos = iPredictiveSearchResultContactLinkArrray->Find(aContactLink);
if(removedContactPos != KErrNotFound)
{
//Remove the link from iPredictiveSearchResultContactLinkArrray
iPredictiveSearchResultContactLinkArrray->Remove(removedContactPos);
}
if (iPredictiveSearchResultContactLinkArrray->Count() == 0)
{
//clear patterns collection
iPatternsCollection.ResetAndDestroy();
// back to name list view
iSearchFilter.FindPaneResetL();
// Reset() must be called after iSearchFilter.FindPaneResetL()
// as it will make some judgment by the content of FindBox.
Reset();
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SendTopViewChangedEvent
// --------------------------------------------------------------------------
void CPbk2PredictiveViewStack::SendTopViewChangedEvent
( MVPbkContactViewBase& aOldTopView )
{
const TInt count = iStackObservers.Count();
for ( TInt i = count - 1; i >= 0; --i )
{
TRAPD( res, iStackObservers[i]->TopViewChangedL( aOldTopView ) );
if ( res != KErrNone )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING
("CPbk2FilteredViewStack::SendTopViewChangedEvent:error %d"),
res );
iStackObservers[i]->ViewStackError( res );
}
}
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::SendTopViewUpdatedEvent
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SendTopViewUpdatedEvent()
{
const TInt count = iStackObservers.Count();
for ( TInt i = count - 1; i >= 0; --i )
{
TRAPD( res, iStackObservers[i]->TopViewUpdatedL() );
if ( res != KErrNone )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING
("CPbk2FilteredViewStack::SendTopViewUpdatedEvent:error %d"),
res );
iStackObservers[i]->ViewStackError( res );
}
}
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::SendBaseViewChangedEvent
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SendBaseViewChangedEvent()
{
const TInt count = iStackObservers.Count();
for ( TInt i = count - 1; i >= 0; --i )
{
TRAPD( res, iStackObservers[i]->BaseViewChangedL() );
if ( res != KErrNone )
{
PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING
("CPbk2FilteredViewStack::SendBaseViewChangedEvent:error %d"),
res );
iStackObservers[i]->ViewStackError( res );
}
}
}
// ---------------------------------------------------------------------------
// CPbk2PredictiveViewStack::LastPCSQuery
// ---------------------------------------------------------------------------
const CPsQuery* CPbk2PredictiveViewStack::LastPCSQuery() const
{
return iSearchedState?iPsQuery:NULL;
}
// ---------------------------------------------------------------------------
// CPbk2PredictiveViewStack::PSHandler
// ---------------------------------------------------------------------------
CPSRequestHandler* CPbk2PredictiveViewStack::PSHandler() const
{
return iPsHandler;
}
// ---------------------------------------------------------------------------
// CPbk2PredictiveViewStack::CreatePatternsL()
// ---------------------------------------------------------------------------
void CPbk2PredictiveViewStack::CreatePatternsL(RPointerArray<CPsPattern>& searchSeqs)
{
iPatternsCollection.ResetAndDestroy();
iBidiPatterns.ResetAndDestroy();
TBidirectionalState::TRunInfo* runInfoArray = new (ELeave)TBidirectionalState::TRunInfo[4];
for (TInt i = 0; i < searchSeqs.Count(); i++)
{
//create standard pattern
TInt nIndex = searchSeqs[i]->FirstIndex();
TDesC& patternText = searchSeqs[i]->Pattern();
CPsPattern* pattern = CPsPattern::NewL();
iPatternsCollection.Append(pattern);
pattern->SetFirstIndex( nIndex );
pattern->SetPatternL( patternText );
//create bidirectional pattern
HBufC* bidiPattern = HBufC::NewLC( patternText.Length() + TBidiLogicalToVisual::KMinCharAvailable );
TPtr tmpPtr2 = bidiPattern->Des();
TBidiLogicalToVisual converter2( patternText, runInfoArray, /*runInfoArrayMaxLength*/4 ) ;
converter2.Reorder();
converter2.GetVisualLine( tmpPtr2, 0, patternText.Length(), TChar(0xffff) );
iBidiPatterns.Append( bidiPattern );
CleanupStack::Pop( bidiPattern );
}
delete runInfoArray;
}
// ---------------------------------------------------------------------------
// CPbk2PredictiveViewStack::GetMatchingPartsL()
// Main assumption to use this method only for bidirectional
// languages and patterns
// ---------------------------------------------------------------------------
void CPbk2PredictiveViewStack::GetMatchingPartsL( const TDesC& aSearchData,
RArray<TPsMatchLocation>& aMatchLocation) const
{
// If list of mathes empty just return
if ( iPatternsCollection.Count() == 0 )
{
return;
}
//This method is implemented for bidirectional languages only
RBuf parserText;
parserText.CreateL(aSearchData);
parserText.CleanupClosePushL();
TLex lexParser(parserText);
TPtrC ptr;
//parse for all words in contact information
TInt currentPos = 0;
lexParser.SkipSpace();
currentPos = lexParser.Offset();
for (ptr.Set(lexParser.NextToken()); ptr.Length(); ptr.Set(lexParser.NextToken()) )
{
//loop by all patterns
for (TInt j = iBidiPatterns.Count() - 1; j >= 0; j--)
{
HBufC* pattern = iBidiPatterns[j];
TInt pos = ptr.Find(pattern->Des());
if ( pos != KErrNotFound)
{
//check if pattern is in th end of the string
if ( (pos + pattern->Length()) == ptr.Length() )
{
// add math to output array
TPsMatchLocation location;
location.index = currentPos + pos;
location.length = pattern->Length();
location.direction = TBidiText::ELeftToRight;
aMatchLocation.Append(location);
break;
}
}
}
lexParser.SkipSpace();
currentPos = lexParser.Offset();
}
CleanupStack::PopAndDestroy();//parserText
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SetCurrentGroupLinkL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SetCurrentGroupLinkL( MVPbkContactLink* aGroupLinktoSet)
{
//Create contactid converter instance for default store if not already exists
if(!iConverterDefaultStore)
{
CVPbkContactManager& manager = Phonebook2::Pbk2AppUi()->
ApplicationServices().ContactManager();
MVPbkContactStore* defaultStore = manager.ContactStoresL().Find(
VPbkContactStoreUris::DefaultCntDbUri() );
__ASSERT_DEBUG( defaultStore, User::Panic(_L("Pbk2 vstack"), 52));
iConverterDefaultStore = CVPbkContactIdConverter::NewL( *defaultStore );
}
//Delete the existing group link
if(iCurrentGroupLink)
{
delete iCurrentGroupLink;
iCurrentGroupLink = NULL;
}
iCurrentGroupLink = aGroupLinktoSet->CloneLC();
CleanupStack::Pop();
if(iCurrentGroupLink)
{
RPointerArray<TDesC> databases;
RBuf storeUrl;
//CleanupResetAndDestroyPushL( databases );
// Set max size for group URI
TInt32 maxLength = sizeof(TInt32) + KVPbkDefaultGrpDbURI().Size() +
KPsGroupDBSuffix().Size() + 2;
storeUrl.CreateL(KVPbkDefaultGrpDbURI(), maxLength);
storeUrl.CleanupClosePushL();
//get group id and create the url to be passed to ps engine
TInt32 id = iConverterDefaultStore->LinkToIdentifier(*iCurrentGroupLink);
storeUrl.AppendFormat(KPsGroupDBSuffix, NULL, id);
databases.AppendL(storeUrl.AllocL());
CleanupStack::PopAndDestroy(&storeUrl);
// Perform the search settings
SetPsSettingL(databases);
databases.ResetAndDestroy();
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SetPsSettingL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SetPsSettingL( RPointerArray<TDesC>& aDatabases)
{
// Perform search settings
CPsSettings* psSettings = CPsSettings::NewL();
CleanupStack::PushL( psSettings );
psSettings->SetSearchUrisL(aDatabases);
RArray<TInt> displayFields;
displayFields.AppendL(R_VPBK_FIELD_TYPE_FIRSTNAME); // Firstname
displayFields.AppendL(R_VPBK_FIELD_TYPE_LASTNAME); // Lastname
displayFields.AppendL(R_VPBK_FIELD_TYPE_COMPANYNAME);// Companyname
psSettings->SetDisplayFieldsL(displayFields);
iPsHandler->SetSearchSettingsL(*psSettings);
//Clean up
CleanupStack::PopAndDestroy(psSettings);
displayFields.Close();
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SaveBookmarkContatsInfoL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SaveBookmarkContatsInfoL()
{
TInt count = iBookMarkCollection->Count();
for ( TInt i = count-1; i >= 0; i-- )
{
const MVPbkContactBookmark& contactBookmark =
iBookMarkCollection->At( i );
TInt indexInBaseView = iBaseView->IndexOfBookmarkL( contactBookmark );
if ( indexInBaseView != KErrNotFound )
{
MVPbkContactLink* link = iBaseView->CreateLinkLC( indexInBaseView );
// find from Searched result
TInt indexInSearchedResult = iPredictiveSearchResultContactLinkArrray->Find( *link );
TInt matchingTopContactIndex = MatchingTopContactFind( indexInBaseView );
if ( indexInSearchedResult == KErrNotFound &&
matchingTopContactIndex == KErrNotFound )
{
const MVPbkViewContact& contact = iBaseView->ContactAtL( indexInBaseView );
CPbk2ContactPositionInfo* positionInfo = CPbk2ContactPositionInfo::NewLC( link, indexInBaseView );
CleanupStack::Pop( positionInfo );
CleanupStack::Pop(); // link
CleanupStack::PushL( positionInfo );
// non matching marked top contacts
if ( iTopContactManager->IsTopContact( contact ) )
{
iTopContactPositionInfoArray.AppendL( positionInfo );
}
else
{
// non matching marked contacts(non top)
iMarkedContactsPositionInfoArray.AppendL( positionInfo );
}
CleanupStack::Pop( positionInfo );
}
else
{
CleanupStack::PopAndDestroy(); // link
}
}
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::MoveArrayToSearchedResultTopL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::MoveArrayToSearchedResultTopL(
RPointerArray<CPbk2ContactPositionInfo>& aContactInfoArray )
{
TInt posZero = 0;
TInt count = aContactInfoArray.Count();
for( TInt i = count-1; i >=0; i-- )
{
CPbk2ContactPositionInfo* positionInfo = aContactInfoArray[ i ];
// ownership of contactLink is transferred
MVPbkContactLink* contactLink = positionInfo->ContactLink();
CleanupStack::PushL( contactLink );
// always insert to the top of iPredictiveSearchResultContactLinkArrray
iPredictiveSearchResultContactLinkArrray->InsertL( contactLink, posZero );
CleanupStack::Pop( contactLink );
// remove positionInfo from iTopContactPositionInfoArray
aContactInfoArray.Remove( i );
delete positionInfo;
}
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::MatchingTopContactFind
// --------------------------------------------------------------------------
//
TInt CPbk2PredictiveViewStack::MatchingTopContactFind( const TInt aIndexInBaseView )
{
TInt ret = KErrNotFound;
TInt topContactCount = iTopContactPositionInfoArray.Count();
for( TInt i = 0; i < topContactCount && ret == KErrNotFound; i++ )
{
CPbk2ContactPositionInfo* topContactPositionInfo =
iTopContactPositionInfoArray[i];
if ( aIndexInBaseView == topContactPositionInfo->Position() )
{
ret = i;
}
}
return ret;
}
// --------------------------------------------------------------------------
// CPbk2PredictiveViewStack::SortbyPositionInMainView
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SortbyPositionInMainView(
RPointerArray<CPbk2ContactPositionInfo>& aContactInfoArray )
{
TLinearOrder< CPbk2ContactPositionInfo >
position( *CPbk2ContactPositionInfo::CompareByPosition );
aContactInfoArray.Sort( position );
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::SendPSNoResultsEventL
// --------------------------------------------------------------------------
//
void CPbk2PredictiveViewStack::SendPSNoResultsEventL()
{
CPsQuery* lastQuery = const_cast<CPsQuery*> (LastPCSQuery());
if ( lastQuery )
{
TDesC& strQuery = lastQuery->QueryAsStringLC();
//Send the matched char Sequence of the first item
//to the Search Pane filter
iSearchFilter.HandlePSNoMatchL( strQuery, KNullDesC );
CleanupStack::PopAndDestroy(); // QueryAsStringLC
}
}
// --------------------------------------------------------------------------
// CPbk2FilteredViewStack::IsNonMatchingMarkedContact
// --------------------------------------------------------------------------
//
TBool CPbk2PredictiveViewStack::IsNonMatchingMarkedContact( const TInt aIndex )
{
TBool ret = EFalse;
if ( aIndex >= iNonMatchedMarkedContactStartIndex &&
aIndex <= iNonMatchedMarkedContactEndIndex )
{
ret = ETrue;
}
return ret;
}
// End of File