MCL/sf/app/speechsrv: comparison srsf/nssvascontacthdlr/src/nssvasccontacthandlerimpl.cpp

equal deleted inserted replaced

--1:000000000000
+:bf1d17376201
+/*
+* Copyright (c) 2005-2006 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:  Responsible for maintaining synchronization between the contact DB
+*               and the VAS DB
+*
+*/
+/** @todo Read the whole contact in one go.
+Currently Contact handler usually opens the same contact (ReadContactL) two to
+three times in order to read its data (mostly often three times).
+One is in GetContactNickname
+Second in GetContactTitle
+Third in DoAddNamesL when deciding what number field should the voice tag
+be trained for
+If we could unite these reads, "reading contacts" phase will be 2-3 times faster.
+It would make about 10-20% improvement for the training of some 300 contacts */
+// INCLUDE FILES
+#include "nssvasccontacthandlerimpl.h"
+#include "nssvasctrainingparameters.h"
+#include <nssvascvasdbmgr.h>
+#include <centralrepository.h>
+#include <f32file.h>
+#include <bautils.h>
+#include <barsc.h>
+#include <barsread.h>
+#include <sysutil.h>
+#include "srsfprivatecrkeys.h"
+// Publish & Subscribe of the contact handler activity
+#include <nssvascoreconstant.h>
+#include <vascvpbkhandler.h>
+#include <featmgr.h>
+#include "nssvasdatasyncwatcher.h"
+#include "nsschbackupobserver.h"
+#include <StringLoader.h>
+#include <nssvascontacthandler.rsg>
+#include <data_caging_path_literals.hrh>
+#include "rubydebug.h"
+// CONSTANTS
+// Name of the context in the SIND DB. Voice tags for contacts are saved there
+_LIT( KNssCHNameDialContext, "NAMEDIAL" );
+// Languages which use lastname-firstname order
+const TLanguage KSwappedLanguages[] =
+{
+ELangHungarian,       // 17
+ELangTaiwanChinese,   // 29
+ELangHongKongChinese, // 30
+ELangJapanese,        // 32
+ELangPrcChinese,      // 31
+ELangKorean,          // 65
+ELangVietnamese       // 96
+};
+// Number of languages that use lastname-firstname order
+const TInt KNumberOfSwappedLanguages = sizeof( KSwappedLanguages ) / sizeof ( TLanguage );
+// Maximal number of retrials to save tags
+const TInt KVASCHMaxRetry = 2;
+// Size of the event 'pack'. Tags are added and deleted in groups.
+// KMaxNamesAtOnce is the maximal size of a group
+const TInt KMaxNamesAtOnce = 100;
+// Initial value of the time interval used to detect periodic action. In
+// microseconds. If KEventMomentsSize events happened  within the
+// KInitialPeriodicActionInterval, we assume, that periodic action has started
+const TInt KInitialPeriodicActionInterval = 15000000;
+// Time interval used to periodically check if there are pending
+// events to process. In microseconds
+const TInt KPeriodicTimerInterval = 1000000;
+// If there are this many consecutive full resyncs initiated by errors during
+// handling normal changes (or during previous full resync), there is probably
+// something consistently wrong at the lower layers.
+// Full resync trials (and the whole contact handler) should be disabled until
+// reboot after KMaxConsecutiveErrorFullResync consecutive unsuccessful trials
+const TInt KMaxConsecutiveErrorFullResync = 2;
+// List of phonebook fields, that are supported by contact handler.
+// I.e. fields, that can be dialed and voice tagged
+/** @todo Consider using information from phonebook about which fields contain numbers
+and using the following lists for priorities only */
+const TPbkFieldId KTaggableFields[] =
+{
+EPbkFieldIdPhoneNumberMobile,
+EPbkFieldIdPhoneNumberGeneral,
+EPbkFieldIdPhoneNumberStandard,
+EPbkFieldIdPhoneNumberHome,
+EPbkFieldIdPhoneNumberWork,
+EPbkFieldIdPhoneNumberVideo,
+EPbkFieldIdVOIP,
+EPbkFieldIdXsp
+};
+const TInt KTaggableFieldsCount = sizeof( KTaggableFields ) / sizeof ( TPbkFieldId );
+// List of phonebook fields that are supported by video extension
+const TPbkFieldId KVideoExtensionFields[] =
+{
+EPbkFieldIdPhoneNumberVideo,
+EPbkFieldIdPhoneNumberMobile,
+EPbkFieldIdPhoneNumberGeneral,
+EPbkFieldIdPhoneNumberHome,
+EPbkFieldIdPhoneNumberWork
+};
+const TInt KVideoExtensionFieldsCount = sizeof( KVideoExtensionFields ) / sizeof ( TPbkFieldId );
+// List of phonebook fields that are supported by message extension
+const TPbkFieldId KMessageExtensionFields[] =
+{
+EPbkFieldIdPhoneNumberMobile,
+EPbkFieldIdPhoneNumberGeneral,
+EPbkFieldIdPhoneNumberHome,
+EPbkFieldIdPhoneNumberWork,
+EPbkFieldIdPhoneNumberVideo
+};
+const TInt KMessageExtensionFieldsCount = sizeof( KMessageExtensionFields ) / sizeof ( TPbkFieldId );
+// List of phonebook fields that are supported by VOIP extension
+const TPbkFieldId KVOIPExtensionFields[] =
+{
+EPbkFieldIdVOIP,
+EPbkFieldIdXsp
+};
+const TInt KVOIPExtensionFieldsCount = sizeof( KVOIPExtensionFields ) / sizeof ( TPbkFieldId );
+// Size of the client data per context. Is used to store the context language
+// In bytes
+const TInt KClientDataSize = sizeof(TNssContextClientData);
+// Number of retries to try to lock the same contact
+// 600 times should stand for 10 mins
+// -1 means trying forever
+const TInt KMaxContactLockRetrials = 600;
+// Interval between the ticks of the contact wait timer
+// in microseconds
+const TInt32 KContactWaitInterval = 1000000;
+// Bytes that should be free in the disk drive in addition to critical level
+// before operation is started (100kB)
+const TInt KIncreaseOfDatabaseSizes = 100000;
+// Define this if name free-order is enabled
+//#define NSSVAS_CONTACTHANDLER_FREEORDER
+// LOCAL FUNCTION DECLARATIONS
+// ================= MEMBER FUNCTIONS =======================
+#ifdef _DEBUG
+_LIT( KFile, "VasCContactHandlerImpl.cpp" );
+#endif
+/**
+* Is used in DoHandleEventFailedL to *asynchronously* simulate successful tag
+*  deletion
+*/
+NONSHARABLE_CLASS( CSuccessfulDeletionSimulator ) : public CAsyncOneShot
+	{
+	public:
+		CSuccessfulDeletionSimulator( CNssContactHandlerImplementation& aHost );
+		~CSuccessfulDeletionSimulator();
+	protected:
+	    /** Is called by the system after we asked it to Call() closer
+	    */
+		virtual void RunL();
+private:
+CNssContactHandlerImplementation& iHost;
+	};
+// -----------------------------------------------------------------------------
+// CSuccessfulDeletionSimulator::~CSuccessfulDeletionSimulator
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSuccessfulDeletionSimulator::~CSuccessfulDeletionSimulator()
+{
+RUBY_DEBUG0( "~CSuccessfulDeletionSimulator" );
+if( IsAdded() )
+{
+RUBY_DEBUG0( "~CSuccessfulDeletionSimulator Request is still in progress, deque it" );
+Deque();
+}
+}
+// -----------------------------------------------------------------------------
+// CSuccessfulDeletionSimulator::CSuccessfulDeletionSimulator
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CSuccessfulDeletionSimulator::CSuccessfulDeletionSimulator( CNssContactHandlerImplementation& aHost ) :
+	CAsyncOneShot( CActive::EPriorityStandard ),
+	iHost( aHost )
+	{
+	//nothing
+	}
+// -----------------------------------------------------------------------------
+//  CAppCloser::RunL
+//  Will be called by the system and exits the application
+// -----------------------------------------------------------------------------
+//
+void CSuccessfulDeletionSimulator::RunL()
+	{
+	RUBY_DEBUG0( "CSuccessfulDeletionSimulator::RunL Start" );
+	if( iStatus == KErrNone )
+		{
+		CArrayPtrFlat<MNssTag>* empty = new (ELeave) CArrayPtrFlat<MNssTag>( 1 );
+	iHost.DoRemoveNamesAfterGetTagList( empty );
+	// empty will be destroyed in the DoRemoveNamesAfterGetTagList
+		}
+	else
+		{
+		RUBY_ERROR1( "CSuccessfulDeletionSimulator::RunL Unexpected iStatus [%d]", iStatus.Int() );
+		}
+	RUBY_DEBUG0( "CSuccessfulDeletionSimulator::RunL End" );
+	}
+// -----------------------------------------------------------------------------
+// CNssContactHandlerImplementation::CNssContactHandlerImplementation
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CNssContactHandlerImplementation::CNssContactHandlerImplementation( )
+: iState( ECHInitializing ),
+iSeparator( KNameSeparator()[0] ),
+iEndOfPeriodicActionInterval( KInitialPeriodicActionInterval )
+{
+iClientData.iLanguage = ELangNone;
+// initialize last RestartTimer calls to be long ago in
+// the past (January 1st, 0 AD nominal Gregorian)
+for( TInt i = 0; i < KEventMomentsSize; i++)
+	{
+	iEventMoments[i] = 0;
+	}
+}
+// -----------------------------------------------------------------------------
+// CNssContactHandlerImplementation::ConstructL
+// EPOC second phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::ConstructL()
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::ConstructL" );
+User::LeaveIfError( iFSession.Connect() );
+// Sets up TLS, must be done before FeatureManager is used.
+FeatureManager::InitializeLibL();
+iVoIPFeatureSupported = FeatureManager::FeatureSupported( KFeatureIdCommonVoip );
+iVideoCallFeatureSupported = FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony );
+// Frees the TLS! Must be done after FeatureManager is used.
+FeatureManager::UnInitializeLib();
+// Before enabling event, start monitoring the PC-suite state
+iSyncBackupWaiter = new (ELeave) CActiveSchedulerWait;
+iDataSyncWatcher = CNssDataSyncWatcherFactory::ConstructDataSyncWatcherL( *this );
+iBackupObserver = CNssChBackupObserver::NewL( *this );
+iContactWaiter = new (ELeave) CActiveSchedulerWait;
+iDeletionSimulator = new (ELeave) CSuccessfulDeletionSimulator( *this );
+EnableEventHandling();
+iEventArray.Reset();    // Ready to be used
+TInt errProp = iBusyProperty.Define( KSINDUID, ETrainingContactsState, RProperty::EInt );
+if( ( errProp != KErrNone ) && ( errProp != KErrAlreadyExists ) )
+{
+RUBY_ERROR1("CNssContactHandlerImplementation::ConstructL() Failed to define the property. Error [%d]",
+errProp);
+User::Leave( errProp );
+}
+// Publish contact handler as busy before the DB operations
+errProp = iBusyProperty.Attach( KSINDUID, ETrainingContactsState );
+if( errProp != KErrNone )
+{
+// KErrNotFound is also an error as we just defined the property
+RUBY_ERROR1("CNssContactHandlerImplementation::ConstructL() Failed to attach to property. Error [%d]",
+errProp);
+User::Leave( errProp );
+}
+errProp = iBusyProperty.Set( EContactsTraining );
+if ( errProp != KErrNone )
+{
+RUBY_ERROR1("CNssContactHandlerImplementation::ConstructL() Failed to set property. Error [%d]",
+errProp );
+User::Leave( errProp )  ;
+}
+// central repository
+iRepository = CRepository::NewL( KCRUidSRSFSettings );
+iRepositoryObserver = CCenRepNotifyHandler::NewL( *this, *iRepository,
+CCenRepNotifyHandler::EIntKey,
+KSRSFFullResyncNeeded );
+iRepositoryObserver->StartListeningL();
+	//Get VAS DB manager
+	iVasDbManager = CNssVASDBMgr::NewL();
+	iVasDbManager->InitializeL();
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::ConstructL iVasDbManager initialized" );
+	//Get Tag Manager and Context Manager interfaces
+	iTagManager = iVasDbManager->GetTagMgr();
+	iContextManager = iVasDbManager->GetContextMgr();
+// Prepare training parameters
+iTrainingParams = CNssTrainingParameters::NewL();
+RUBY_DEBUG0( "CNssContactHandlerImplementation::ConstructL iTrainingParams prepared" );
+// Set languages which have lastname-firstname order
+for ( TInt iCounter = 0; iCounter < KNumberOfSwappedLanguages; iCounter++ )
+{
+User::LeaveIfError( iSwappedLanguages.Append( KSwappedLanguages[iCounter] ) );
+}
+#ifdef __SINDE_TRAINING
+// Main array for languages
+RArray<RTrainingLanguageArray> languages;
+// Languages for names
+RArray<TLanguage> nameLanguages;
+User::LeaveIfError( nameLanguages.Append( User::Language() ) );
+User::LeaveIfError( nameLanguages.Append( ELangOther ) );
+User::LeaveIfError( languages.Append( nameLanguages ) );
+// Languages for extensions
+RArray<TLanguage> extLanguages;
+User::LeaveIfError( extLanguages.Append( User::Language() ) );
+User::LeaveIfError( languages.Append( extLanguages ) );
+// Store languages to training parameters
+iTrainingParams->SetSindeLanguages( languages );
+// Close arrays, iTrainingParams has done a copy of these
+extLanguages.Close();
+nameLanguages.Close();
+languages.Close();
+#else
+// Set the languages
+RArray<TLanguage> *languages = new (ELeave) RArray<TLanguage>;
+CleanupStack::PushL( languages );
+// Always generate a pronunciation in UI language
+User::LeaveIfError( languages->Append( User::Language() ) );
+// give some extra languages, which can be selected in engine
+User::LeaveIfError( languages->Append( ELangOther ) );
+iTrainingParams->SetLanguages( languages );
+CleanupStack::Pop( languages );
+#endif
+// The separator between the first name and the last name
+iTrainingParams->SetSeparator( iSeparator );
+#ifdef __SIND_EXTENSIONS
+ReadExtensionsL();
+#endif // __SIND_EXTENSIONS
+	ConnectToPhonebookL();
+TLitC<9> name = KNssCHNameDialContext;
+// Get context.
+// (1) if we have synced earlier -> we have created a context, and saved the language
+// (2) if we haven't synced      -> we need to create context
+//
+// In case (2), GetContext fails.
+// We'll assume that GetContext is successful until it fails.
+iHaveWeEverSynced = ETrue;
+TInt err = iContextManager->GetContext( this, name );
+RUBY_DEBUG1( "CNssContactHandlerImplementation::ConstructL Requested GetContext. err [%d]", err);
+if ( err != KErrNone )
+{
+// The same function is called, whether GetContext fails synchronously
+// or asynchronously.
+GetContextCompleted( NULL, KErrNotFound );
+}
+	iDeleteTagListArray = new (ELeave) CArrayPtrFlat<MNssTag>(50);
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::NewL
+// Two-phased constructor.
+// ---------------------------------------------------------
+//
+CNssContactHandlerImplementation* CNssContactHandlerImplementation::NewL( )
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::NewL" );
+CNssContactHandlerImplementation* self = new (ELeave) CNssContactHandlerImplementation();
+CleanupStack::PushL( self );
+self->ConstructL();
+CleanupStack::Pop( self );
+return self;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::~CNssContactHandlerImplementation
+// Destructor
+// ---------------------------------------------------------
+//
+CNssContactHandlerImplementation::~CNssContactHandlerImplementation()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::~CNssContactHandlerImplementation FIXED" );
+iFSession.Close();
+iEventArray.Close();     // Close the RArray
+delete iDataSyncWatcher;
+delete iBackupObserver;
+if ( iSyncBackupWaiter != NULL )
+{
+if( iSyncBackupWaiter->IsStarted() )
+{
+iSyncBackupWaiter->AsyncStop();
+}
+}
+delete iSyncBackupWaiter;
+if ( iContactWaiter != NULL )
+{
+if( iContactWaiter->IsStarted() )
+{
+iContactWaiter->AsyncStop();
+}
+}
+delete iContactWaiter;
+delete iDeletionSimulator;
+delete iPeriodicHandleEventTimer;
+delete iContext;
+delete iVasDbManager;
+RProperty::Delete( KSINDUID, ETrainingContactsState );
+iBusyProperty.Close();
+delete iRepositoryObserver;
+delete iRepository;
+delete iTrainingParams;
+iTagArray.ResetAndDestroy();
+for( TInt k( 0 ); k < iContactQueue.Count(); k++ )
+{
+delete iContactQueue[k].iTitle;
+}
+iContactQueue.Close();
+iDelList.Close();
+iAddList.Close();
+iRemoveIconList.Close();
+iVoiceTagAddedList.Close();
+iSwappedLanguages.Close();
+DisconnectFromPhonebook();
+#ifdef __SIND_EXTENSIONS
+for ( TInt i(0); i < iExtensionList.Count(); i++ )
+{
+delete iExtensionList[i].iText;
+}
+iExtensionList.Close();
+#endif // __SIND_EXTENSIONS
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::HandleEventL
+// Called by phonebook handler when a contact database event
+// occurs
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::HandleEventL( const TPhonebookEvent& aEvent )
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::HandleEventL" );
+RUBY_DEBUG2( "CNssContactHandlerImplementation::HandleEventL(). Contact id [%d], event type [%d]", aEvent.iContactId, aEvent.iType );
+if ( aEvent.iType == EContactChanged ||
+aEvent.iType == EContactDeleted ||
+aEvent.iType == EContactAdded   ||
+aEvent.iType == EUnknownChanges )
+{
+if( !CausedByVoiceTagAddition( aEvent ) )
+	{
+	// Check if operations can be finished
+	// There should be enough disk space
+	if ( NoDiskSpace() )
+	    {
+	    RUBY_DEBUG0( "CNssContactHandlerImplementation::HandleEventL not enough disk space, disabling event handling" );
+	    DisableEventHandling();
+	    }
+	else
+	    {
+TInt errProp = iBusyProperty.Set( EContactsTraining );
+if ( errProp != KErrNone )
+{
+RUBY_ERROR1("CNssContactHandlerImplementation::ConstructL() Failed to set property. Error [%d]",
+errProp );
+User::Leave( errProp )  ;
+}
+	    UpdatePeriodicActionVars();
+	            iEventArray.Append( aEvent );
+	        if ( iState == ECHIdle )
+	     	{
+	    RUBY_DEBUG0( "CNssContactHandlerImplementation::HandleEventL() iState == ECHIdle => DoHandleEvent" );
+	    // Process the first new event from the queue
+	    TRAPD( err, DoHandleEventsL() );
+	    RUBY_DEBUG1( "CNssContactHandlerImplementation::HandleEventL. Assert would fail and Panic IF err != KErrNone. err [%d]", err );
+RUBY_ASSERT_DEBUG( err == KErrNone, User::Panic( KFile, __LINE__ ) );
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::HandleEventL. Error [%d] in DoHandleEventsL", err );
+}
+}
+	    else
+	        	    {
+	        	    RUBY_DEBUG1( "CNssContactHandlerImplementation::HandleEventL() iState == [%d] => Do not handle the event right now", iState );
+	        	    } // if iState else
+	    }
+}  // if caused be voice tag addition
+	    else
+	{
+			RUBY_DEBUG2( "CNssContactHandlerImplementation::HandleEventL(). Event for Contact id [%d] was caused by a voice icon addition and will be ignored, eventArray size [%d]", aEvent.iContactId, iEventArray.Count() );
+			if ( ( iVoiceTagAddedList.Count() == 0 ) && ( iState == ECHIdle ) && ( iEventArray.Count() == 0 ) )
+			    {
+			    RUBY_DEBUG0( "HandleEventL No more voice icon events expected, nothing pending." );
+			    }
+			else
+			    {
+			    RUBY_DEBUG1( "HandleEventL [%d] voice icon events are still expected", iVoiceTagAddedList.Count() );
+			    }
+	}
+}
+else if ( aEvent.iType == EStoreRestoreBeginning )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::HandleEventL restore begin" );
+iRestoreRunning = ETrue; // set to differentiate ending of restore or backup
+}
+else if ( aEvent.iType == EStoreBackupRestoreCompleted && iRestoreRunning )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::HandleEventL restore end" );
+// Set value to make full resync
+SetFullResyncCrFlagL( ETrue );
+iRestoreRunning = EFalse;
+} // if event type
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoHandleEventL
+// Process the Event from phonebook
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoHandleEventsL()
+	{
+	RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::DoHandleEventsL" );
+	RUBY_DEBUG1( "CNssContactHandlerImplementation::DoHandleEventsL, eventArray size [%d]", iEventArray.Count() );
+	// If there is no lengthy higher level routine executed
+	if( !PeriodicAction() )
+		{
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL !PeriodicAction()" );
+		if ( iHandlerEnabled )
+	{
+	    	if ( IsFullResyncNeeded() )
+		   	{
+			RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL() Full resync if needed. Setting iState to ECHFullResync" );
+				SetState( ECHFullResync );
+	iEventArray.Close();
+	        	FullResyncStart();
+	    	}
+			else
+	   		{
+			RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL() Full resync if NOT needed. Setting iState to ECHHandlingNormalChanges" );
+			SetState( ECHHandlingNormalChanges );
+			// There are 3 phases in handling events:
+	          	// (1) Make two lists:
+	     	 	//  * Names to be added
+	  		//  * Names to be deleted
+		CollectAddRemoveListsL();
+	      		// (2) Delete the names to be deleted. This operation is asynchronous.
+	  		DoRemoveNamesL();
+			// (3) After removing names, add the names to be added.
+// DoRemoveNamesL() starts the step (3)
+		}
+		}
+	else
+		{
+		// In UREL, empty "else" branch will be eliminated by the compiler
+			RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL() Handler was disabled" );
+		}
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL() completed" );
+		}// if !PeriodicAction
+	else
+		{
+		// In UREL, empty "else" branch will be eliminated by the compiler
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventsL PeriodicAction detected, DoHandleEventsL omitted" );
+		}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DeleteTagCompleted
+// Called when the deletion of a tag is completed successfully
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DeleteTagCompleted( TInt aErrorCode )
+	{
+	if( aErrorCode == KErrNone )
+	    {
+	RUBY_DEBUG1( "CNssContactHandlerImplementation::DeleteTagCompleted. Assert iState == ECHHandlingNormalChanges. iState [%d]", iState);
+RUBY_ASSERT_DEBUG( iState == ECHHandlingNormalChanges, User::Panic( KFile, __LINE__ ) );
+	    }
+else
+{
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DeleteTagCompleted: tag deletion failed" );
+	iNormalChangesError = aErrorCode;
+}
+DoRemoveNamesAfterDeleteTagCompleted();
+	}
+// -----------------------------------------------------------------
+// CNssContactHandlerImplementation::GetTagCompleted
+// Called by tag manager when getting of a tag list completes
+// -----------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::GetTagListCompleted(
+MNssTagListArray* aTagList, TInt aErrorCode )
+{
+if( aErrorCode == KErrNone )
+{
+if ( iState == ECHHandlingNormalChanges )
+{
+DoRemoveNamesAfterGetTagList( aTagList );
+}
+else
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::GetTagListCompleted : Unknown state(%d)\n", iState );
+		}
+}
+else
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::GetTagListCompleted. Error [%d]", aErrorCode );
+TRAPD( err, DoHandleEventFailedL() );    // Process the event fail
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::GetTagFailed. Error [%d] in DoHandleEventFailedL", err );
+}
+}
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DisableEventHandling
+// Disables the event handling. Is used in case of unrecoverable error
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DisableEventHandling()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DisableEventHandling" );
+iHandlerEnabled = EFalse;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::EnableEventHandling
+// Enables event handling
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::EnableEventHandling()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::EnableEventHandling" );
+iHandlerEnabled = ETrue;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::GetContextListCompleted
+// Called by tag manager when GetContextList() completes successfully
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::GetContextListCompleted(
+MNssContextListArray*  /*aContextList*/, TInt /*aErrorCode*/ )
+{
+RUBY_ERROR0( "CNssContactHandlerImplementation::GetContextListCompleted - this function should never be called." );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::CheckErrorSigns
+// Compares client data (saved in VAS context)
+// to state of the phonebook to find out if
+// full synchronization is needed.
+//
+// If full resync is needed initiates it by saving into the event queue
+// special 'full resync event'
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::CheckErrorSigns()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::CheckErrorSigns" );
+TBool errorFound( EFalse );
+// Full resync, if this is the first time we launch.
+//              if the UI language has changed.
+//              if VAS Db and Contact Db time stamps do not match
+if  ( iClientData.iLanguage == ELangNone ||
+iClientData.iLanguage != User::Language() )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::CheckErrorSigns language changed." );
+errorFound = ETrue;
+}
+else
+{
+// check that is full resyncronization needed
+iRepository->Get( KSRSFFullResyncNeeded, errorFound );
+}
+if ( errorFound )
+{
+TPhonebookEvent event;
+	event.iType = ENullEvent;
+	event.iContactId = 0;
+if ( iEventArray.Append( event ) != KErrNone )
+{
+RUBY_ERROR0( "CNssContactHandlerImplementation::CheckErrorSigns Failed to append to iEventArray" );
+}
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::GetContextCompleted
+// Called by tag manager, when GetContext() completes successfully
+//
+// Depending on the contact handler state, continues full resync sequence or
+// sets the idle state
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::GetContextCompleted(
+MNssContext* aContext, TInt aErrorCode )
+	{
+	if( aErrorCode == KErrNone )
+	    {
+RUBY_ASSERT_DEBUG( iState == ECHInitializing || iState == ECHFullResync,
+User::Panic( KFile, __LINE__ ) );
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::GetContextCompleted" );
+iContext = aContext;
+TRAPD(err,
+iClientData.InternalizeL( iContext->ClientData() );
+	    if ( iState == ECHInitializing )
+	        {
+	        // If there are warning sings of error,
+	        // do full resynchronization.
+	        CheckErrorSigns();
+	        SetState( ECHIdle );
+	        RUBY_DEBUG0( "CNssContactHandlerImplementation::GetContextCompleted. Setting iState to ECHIdle" );
+	        if ( iEventArray.Count() ) // Verify whether more events in the queue
+	            {
+	    		RUBY_DEBUG1( "CNssContactHandlerImplementation::GetContextCompletedhere are still [%d] events in the queue. Call DoHandleEvents for them", iEventArray.Count() );
+	            DoHandleEventsL(); // Process the 1st new event from the queue
+	            }
+	        }
+	    else if ( iState == ECHFullResync )
+	        {
+	        TRAPD( error,  FullResyncCreateChangesL() );
+	        if( error != KErrNone )
+	            {
+	            RUBY_ERROR1( "FullResyncCreateChangesL failed with [%d]. Panic, nothing can be done", error );
+	            RUBY_ASSERT_DEBUG( EFalse, User::Panic( KFile, __LINE__ ) );
+	            }
+	        }
+	    else
+	    	{
+	    	RUBY_ERROR0( "CNssContactHandlerImplementation::GetContextCompleted Unexpected state" );
+	    	RUBY_ASSERT_DEBUG( EFalse, User::Panic( KFile, __LINE__ ) );
+	    	}
+	    );  // TRAPD
+	if( err != KErrNone )
+		{
+		RUBY_ERROR1( "CNssContactHandlerImplementation::GetContextCompleted Leaves with [%d] inside", err );
+		}
+RUBY_DEBUG0( "CNssContactHandlerImplementation::GetContextCompleted completed" );
+	    }
+	else // aErrorCode != KErrNone
+	    {
+RUBY_ASSERT_DEBUG( iState == ECHInitializing || iState == ECHFullResync,
+User::Panic( KFile, __LINE__ ) );
+if ( iState == ECHInitializing )
+{
+iHaveWeEverSynced = EFalse;
+SetState ( ECHFullResync );
+FullResyncStart();
+}
+	    }
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::SaveContextCompleted
+// Called when SaveContext() completes successfully
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::SaveContextCompleted( TInt aErrorCode )
+{
+if( aErrorCode == KErrNone )
+{
+RUBY_ASSERT_DEBUG( iState == ECHInitializing ||
+iState == ECHFullResync,
+User::Panic( KFile, __LINE__ ) );
+iHaveWeEverSynced = ETrue;
+if ( iState == ECHInitializing )
+{
+// Retrive the Context to get the new ContextId from VasDB
+iContextManager->GetContext( this, KNssCHNameDialContext );
+}
+else if ( iState == ECHFullResync )
+{
+TRAPD( error, FullResyncCreateChangesL() );
+if ( error != KErrNone )
+{
+RUBY_ERROR1( "SaveContextCompleted Failed to create full resync changes. Critical error [%d]",
+error );
+DisableEventHandling();
+}  // if error != KErrNone
+}  // else if ( iState == ECHFullResync )
+else
+	{
+	// we should never be here, because the condition is checked
+	// by ASSERT_DEBUG at the start of the function
+	RUBY_ERROR0( "CNssContactHandlerImplementation::SaveContextCompleted Unexpected state!" );
+	}
+}
+else // aErrorCode != KErrNone
+{
+// Failed to initialize will collect the events forever and will never process them
+// Will try to initialize again after reboot
+RUBY_ERROR0( "CNssContactHandlerImplementation::SaveContextCompleted failed. Staying forever in ECHFullResync" );
+RUBY_ERROR0( "CNssContactHandlerImplementation::SaveContextCompleted failed. Reboot to try initializing again" );
+DisableEventHandling();
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::SaveTagCompleted
+// Called when SaveTag() completes
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::SaveTagCompleted( TInt aErrorCode )
+{
+RUBY_ASSERT_DEBUG( iState == ECHHandlingNormalChanges, User::Panic( KFile, __LINE__ ) );
+DoAddNamesSaveTagCompleted( aErrorCode );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::GetContactTitleL
+// Populates aTitle with either "FirstName LastName" or "CompanyName".
+// "CompanyName" is given only if both First and Last names are missing.
+//---------------------------------------------------------
+//
+HBufC* CNssContactHandlerImplementation::GetContactTitleL( TContactItemId aContactId,
+TBool aUseDefaultOrder,
+TBool& aBothFirstAndLastFound,
+TVasTagType& aTagType )
+	{
+	RUBY_DEBUG_BLOCKL( "CNssContactHandlerImplementation::GetContactTitleL" );
+// Find out if lastname-firstname should be used
+TBool useLastFirstOrder = EFalse;
+// By default, this function returns firstname and/or lastname
+aTagType = ETagTypeName;
+if ( aUseDefaultOrder )
+{
+useLastFirstOrder = SwapNameOrder();
+}
+else
+{
+useLastFirstOrder = !SwapNameOrder();
+}
+WaitUntilNoSyncBackupIsRunning();
+ReadContactL( aContactId );
+HBufC* firstNameText = NULL;
+HBufC* lastNameText = NULL;
+HBufC* companyNameText = NULL;
+TInt firstLength( 0 );
+TInt lastLength( 0 );
+TInt companyLength( 0 );
+TInt error = KErrNone;
+// name reading fields are used in Japanese
+	TRAP( error, iPbkHandler->FindFieldL( EPbkFieldIdFirstNameReading ) );
+if ( error == KErrNotFound )
+{
+// not found
+TRAP( error, iPbkHandler->FindFieldL( EPbkFieldIdFirstName ) );
+}
+if ( error == KErrNone )
+{
+firstNameText = iPbkHandler->TextL().AllocLC();
+TrimName( firstNameText );
+firstLength = firstNameText->Length();
+if ( firstLength == 0 )
+{
+CleanupStack::PopAndDestroy( firstNameText );
+firstNameText = NULL;
+}
+}
+TRAP( error, iPbkHandler->FindFieldL( EPbkFieldIdLastNameReading ) );
+if ( error == KErrNotFound )
+{
+// not found
+TRAP( error, iPbkHandler->FindFieldL( EPbkFieldIdLastName ) );
+}
+if ( error == KErrNone )
+{
+lastNameText = iPbkHandler->TextL().AllocLC();
+TrimName( lastNameText );
+lastLength = lastNameText->Length();
+if ( lastLength == 0 )
+{
+CleanupStack::PopAndDestroy( lastNameText );
+lastNameText = NULL;
+}
+}
+TRAP( error, iPbkHandler->FindFieldL( EPbkFieldIdCompanyName ) );
+if ( error == KErrNone )
+{
+companyNameText = iPbkHandler->TextL().AllocLC();
+TrimName( companyNameText );
+companyLength = companyNameText->Length();
+if ( companyLength == 0 )
+{
+CleanupStack::PopAndDestroy( companyNameText );
+companyNameText = NULL;
+}
+}
+// Use third parameter to return a flag if both lastname and firstname are found
+if ( ( firstLength > 0 ) && ( lastLength > 0 ) )
+{
+aBothFirstAndLastFound = ETrue;
+}
+else
+{
+aBothFirstAndLastFound = EFalse;
+}
+HBufC* title( NULL );
+#ifdef __SIND_EXTENSIONS
+if ( firstLength + lastLength > 0 )
+{
+TInt spaceForIndexes( 0 );
+// Find out how much more space is needed for "training indexes"
+if ( aBothFirstAndLastFound )
+{
+spaceForIndexes = 2 * KTrainingIndexSize;
+}
+else
+{
+spaceForIndexes = KTrainingIndexSize;
+}
+title = HBufC::NewL( firstLength + lastLength + spaceForIndexes );
+// Check the order
+if ( useLastFirstOrder )
+{
+// Lastname-firstname
+if ( lastNameText )
+{
+AppendName( title, lastNameText );
+}
+if ( firstNameText )
+{
+AppendName( title, firstNameText );
+}
+}
+else
+{
+// Firstname-lastname
+if ( firstNameText )
+{
+AppendName( title, firstNameText );
+}
+if ( lastNameText )
+{
+AppendName( title, lastNameText );
+}
+}
+}
+// Try company name, if the personal name fails.
+else if ( companyLength > 0 )
+{
+aTagType = ETagTypeCompanyName;
+title = HBufC::NewL( companyLength + KTrainingIndexSize );
+AppendName( title, companyNameText );
+}
+#else
+// Use personal name, if there is one.
+if ( firstLength + lastLength > 0 )
+{
+title = HBufC::NewL( firstLength + 1 + lastLength );
+// Check the order
+if ( useLastFirstOrder )
+{
+// Lastname-firstname
+if ( lastNameText )
+{
+title->Des().Append( lastNameText->Des() );
+if ( firstNameText )
+{
+// Separator marker
+title->Des().Append( iSeparator );
+}
+}
+if ( firstNameText )
+{
+title->Des().Append( firstNameText->Des() );
+}
+}
+else
+{
+// Firstname-lastname
+if ( firstNameText )
+{
+title->Des().Append( firstNameText->Des() );
+if ( lastNameText )
+{
+// Separator marker
+title->Des().Append( iSeparator );
+}
+}
+if ( lastNameText )
+{
+title->Des().Append( lastNameText->Des() );
+}
+}
+}
+// Try company name, if the personal name fails.
+else if ( companyLength > 0 )
+{
+aTagType = ETagTypeCompanyName;
+title = HBufC::NewL( companyLength );
+title->Des().Append( companyNameText->Des() );
+}
+#endif // __SIND_EXTENSIONS
+// It is possible to make a contact without a name.
+else
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::ContactTitle: No name, ContactId=[%d]" , aContactId );
+}
+if ( companyNameText )
+{
+CleanupStack::PopAndDestroy( companyNameText );
+}
+if ( lastNameText )
+{
+CleanupStack::PopAndDestroy( lastNameText );
+}
+if ( firstNameText )
+{
+CleanupStack::PopAndDestroy( firstNameText );
+}
+return title;
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::SwapNameOrder
+// Returns ETrue if name order for current UI language should
+// be lastname-firstname, EFalse otherwise
+//---------------------------------------------------------
+//
+TBool CNssContactHandlerImplementation::SwapNameOrder()
+{
+// Find UI language
+TLanguage uiLanguage = User::Language();
+if ( iSwappedLanguages.Find( uiLanguage ) == KErrNotFound )
+{
+return EFalse;
+}
+else
+{
+return ETrue;
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::GetContactNicknameL
+// Returns nickname for a given contact
+//---------------------------------------------------------
+//
+HBufC* CNssContactHandlerImplementation::GetContactNicknameL( TContactItemId aContactId )
+	{
+	RUBY_DEBUG_BLOCKL( "CNssContactHandlerImplementation::GetContactNicknameL" );
+	WaitUntilNoSyncBackupIsRunning();
+ReadContactL( aContactId );
+	// Get the nick name
+	iPbkHandler->FindFieldL( EPbkFieldIdSecondName );
+// Get the length of the additional name.
+TInt nickLength = iPbkHandler->TextL().Length();
+HBufC* title = NULL;
+#ifdef __SIND_EXTENSIONS
+// Use personal name, if there is one.
+if ( nickLength > 0 )
+{
+title = HBufC::NewL( nickLength + KTrainingIndexSize );
+HBufC* nickName = iPbkHandler->TextL().AllocL();
+TrimName( nickName );
+AppendName( title, nickName );
+delete nickName;
+}
+#else
+// Use personal name, if there is one.
+if ( nickLength > 0 )
+{
+title = HBufC::NewL( nickLength );
+title->Des().Append( iPbkHandler->TextL() );
+}
+#endif // __SIND_EXTENSIONS
+return title;
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoHandleEventFailed
+// Routine to process when handling the contact event failed
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoHandleEventFailedL()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventFailedL start" );
+// Errors are normal if user deletes contact without a voice tag
+// E.g. because this contact had no number
+if( ( iDeleteTagListArray != NULL ) && ( iDeleteTagListArray->Count() > 0 ) )
+	{
+	// simulate successful deletion, just return no tags for further deletions
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventFailedL Deletion failed. Simulating successful empty deletion" );
+	iDeletionSimulator->Call();
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventFailedL Called deletion simulator" );
+	}
+else
+	{
+	    // Try full resync couple of times. If still fails, stop contact handler.
+	    // When the phone is booted for the next time, try resyncing again
+	if( iConsecutiveErrorFullResync < KMaxConsecutiveErrorFullResync )
+		{
+		iConsecutiveErrorFullResync++;
+		RUBY_DEBUG1( "CNssContactHandlerImplementation::DoHandleEventFailedL Trying full resync for the [%d] time", iConsecutiveErrorFullResync);
+		// clean structures that might be already full
+		iTagArray.ResetAndDestroy();
+		    for( TInt k( 0 ); k < iContactQueue.Count(); k++ )
+		    	{
+		       	delete iContactQueue[k].iTitle;
+		       	}
+		   	iContactQueue.Close();
+		   	iDelList.Close();
+		   	iAddList.Close();
+		   	iVoiceTagAddedList.Close();
+		// generate full resync event
+		TPhonebookEvent event;
+	event.iType = ENullEvent;
+	event.iContactId = 0;
+	iEventArray.Insert( event, 0 );
+	// will start full resync
+	iTagArray.ResetAndDestroy();
+	iSaveCallbackCounter = 0; // simulate completed action
+	RUBY_DEBUG0( "DoHandleEventFailedL No leaving in the FullResync branch, retrying" );
+	DoHandleEventsL(); // No leaving in the FullResync branch
+		}
+	else
+	    	{
+	    	RUBY_ERROR1( "CNssContactHandlerImplementation::DoHandleEventFailedL Tried full resync for %d times. Disabling contact handler until reboot", KMaxConsecutiveErrorFullResync );
+		// Tried several consecutive resyncs, didn't help
+		// Disable itself until reboot
+		DisableEventHandling();
+		}
+	}  // if deletion else
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoHandleEventFailedL end" );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::PhonebookOrder
+// TLinearOrder comparison function for sorting phonebook events
+// according to their Phonebook ID.
+//---------------------------------------------------------
+//
+TInt CNssContactHandlerImplementation::PhonebookOrder( const TPhonebookEvent& a1, const TPhonebookEvent& a2 )
+{
+if ( a1.iContactId != a2.iContactId )
+{
+return( a1.iContactId - a2.iContactId );
+}
+if ( a1.iTime < a2.iTime )
+{
+return( -1 );
+}
+else if ( a1.iTime > a2.iTime )
+{
+return( 1 );
+}
+else{
+return( 0 );
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::IsFullResyncNeeded
+// Checks if the event queue contains an event, which
+// launches full resynchronization. If it does, there is
+// no point in processing the other events.
+// ---------------------------------------------------------
+//
+TBool CNssContactHandlerImplementation::IsFullResyncNeeded()
+{
+for( TInt k( 0 ); k < iEventArray.Count(); k++ )
+{
+// Null event is used inside contact handler to signal full resync.
+if ( iEventArray[k].iType == ENullEvent
+|| iEventArray[k].iType == EStoreBackupRestoreCompleted
+|| iEventArray[k].iType == EUnknownChanges )
+{
+return ETrue;
+}
+}
+return EFalse;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::CollectAddRemoveListsL
+// Given a list of Contact DB Events, this function compiles
+// a list of ids to-be-deleted and ids to-be-added.
+// A Contact DB Event contains:
+//  * Contact ID
+//  * Event type (added, modified, removed)
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::CollectAddRemoveListsL()
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::CollectAddRemoveListsL" );
+RUBY_DEBUG1( "CNssContactHandlerImplementation::CollectAddRemoveListsL(). iEventArray.Count [%d]", iEventArray.Count() );
+TInt k( 0 );
+	RUBY_ASSERT_DEBUG( iAddList.Count() == 0, User::Panic( KFile, __LINE__ ) );
+RUBY_ASSERT_DEBUG( iDelList.Count() == 0, User::Panic( KFile, __LINE__ ) );
+// We collect two lists:
+//  * Contacts to be deleted.
+//  * Contacts to be added.
+TLinearOrder<TPhonebookEvent> order( PhonebookOrder );
+// Sort events according to the phonebook ID. This way, the events
+// modifying the same name are sequentially.
+iEventArray.Sort( order );
+// If several events happen for the same contact, fuse them into one event.
+for ( k = 0; k < iEventArray.Count() - 1; k++ )
+{
+if ( iEventArray[k].iContactId == iEventArray[k+1].iContactId )
+{
+// Sorting should have preserved the order of the events
+RUBY_ASSERT_DEBUG(iEventArray[k+1].iTime >= iEventArray[k].iTime, User::Panic( KFile, __LINE__ ) );
+RUBY_DEBUG1( "CNssContactHandlerImplementation::CollectAddRemoveListsL(). Fusing events for ContactId [%d]", iEventArray[k].iContactId );
+iEventArray[k+1].iType = EContactChanged;
+iEventArray.Remove( k );
+// We have removed an element
+k--;
+}
+}
+	RUBY_DEBUG1( "CNssContactHandlerImplementation::CollectAddRemoveListsL(). Events sorted and fused iEventArray.Count [%d]", iEventArray.Count() );
+for( k = 0; k < iEventArray.Count() && k < KMaxNamesAtOnce; k++ )
+{
+TPhonebookEvent* event = &iEventArray[k];
+switch ( event->iType )
+{
+case EContactChanged:
+{
+// events caused by saving voice tag field are skipped
+// earlier, in HandleDatabaseEventL
+// We need to delete the old name
+User::LeaveIfError( iDelList.Append( *event ) );
+// and after that, add the new name.
+User::LeaveIfError( iAddList.Append( *event ) );
+break;
+}
+case EContactDeleted:
+{
+User::LeaveIfError( iDelList.Append( *event ) );
+break;
+}
+case EContactAdded:
+{
+User::LeaveIfError( iAddList.Append( *event ) );
+break;
+}
+default:
+RUBY_ERROR1( "CNssContactHandlerImplementation::CollectAddRemoveListsL() Unkown event type: %d", event->iType );
+break;
+}
+}
+if ( k < KMaxNamesAtOnce )
+{
+iEventArray.Close();
+}
+else
+{
+	RUBY_DEBUG1( "CNssContactHandlerImplementation::CollectAddRemoveListsL(). k >= KMaxNamesAtOnce [%d]. Deleting first KMaxNamesAtOnce events, they've been sorted into corresponding lists already",
+	            KMaxNamesAtOnce);
+for ( k = 0; k < KMaxNamesAtOnce; k++ )
+{
+iEventArray.Remove(0);
+}
+}
+RUBY_DEBUG1( "CNssContactHandlerImplementation::CollectAddRemoveListsL() iEventArray.Count [%d]",
+iEventArray.Count());
+	RUBY_DEBUG2( "CNssContactHandlerImplementation::CollectAddRemoveListsL iDelList.Count() [%d], iAddList.Count() [%d]", iDelList.Count(), iAddList.Count());
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoRemoveNamesL
+// Starts name removal sequence
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoRemoveNamesL()
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::DoRemoveNamesL" );
+if ( iDelList.Count() == 0 )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesL Nothing to delete - skipping" );
+RemovingNamesCompletedL();
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesL completed early <= nothing to remove" );
+return;
+}
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesL - removing" );
+// we have: a list of tag IDs, which should be removed
+// we need: a list of tags, which should be removed.
+// First, we get the tags which correspond to the tag ids.
+// We need k async calls to VAS,
+// where k is the number of tag ids in iDelList.
+// We get a list of k' tags, where k' >= k.
+// If some tag has both proper name and a nickname, then k' > k.
+iContactId = iDelList[0].iContactId;
+if ( iDeleteTagListArray )
+{
+iDeleteTagListArray->ResetAndDestroy();
+}
+else
+{
+iDeleteTagListArray = new (ELeave) CArrayPtrFlat<MNssTag>(50);
+}
+TInt retCode = iTagManager->GetTagList( this, iContext, iContactId, 0 );
+if ( retCode != KErrNone )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesL failed to GetTagList" );
+// In the case of change event, try to add names even though they are not found
+// Might happen in scenario like this:
+// 1. User adds a name without any phone number -> no voice tag is created
+// 2. Contact is modified by adding a phone number
+iDelList.Close();
+DoAddNamesL();
+}
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesL completed" );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList
+// If contact database announces that n contacts need to be
+// deleted, we do n calls to GetTagList (the first is from DoRemoveNamesL).
+// Each callback returns 1 or more tags (name + nickname = 2 tags).
+// This function processes the callbacks by adding the tags to the
+// to-be-deleted list.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList( MNssTagListArray* aTagList )
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList. iState [%d]", iState );
+if ( iDelList.Count() == 0 )
+		{
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList iDelList.Count() == 0" );
+		}
+// Sieve out "false" tags: Those which have a wrong contact ID.
+/** Why? Maybe user was fast enough to delete these contacts from the phonebook
+*   Anyway, why should we keep "false" tags in our db?
+*/
+for ( TInt i=0; i < aTagList->Count(); i++ )
+{
+CArrayFixFlat<TInt>* intArray = aTagList->At(i)->RRD()->IntArray();
+RUBY_ASSERT_DEBUG( intArray->Count() > 0, User::Panic( KFile, __LINE__ ) );
+if ( intArray->At(0) != iContactId )
+{
+RUBY_ERROR2( "DoRemoveNamesAfterGetTagList expected contact id %d, but got contact id: %d", iContactId, intArray->At(0) );
+delete aTagList->At( i );
+aTagList->Delete( i );
+}
+}
+TRAPD( err, // trapping is a fix to make the function non-leaving
+	    // Add the tags to the to-be-deleted list.
+	    // (there are 1 or 2 tags in aTagList depending on
+	    //  whether nickname is also there or not)
+	    for ( TInt k( 0 ); k < aTagList->Count(); k++ )
+	        {
+	        iDeleteTagListArray->AppendL( (*aTagList)[k] );
+	        }
+	    // We have processed this ID
+	    RUBY_DEBUG1( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList Before removal. iDelList.Count [%d]", iDelList.Count() );
+	    if( iDelList.Count() > 0 )
+	    	{
+	    	iDelList.Remove( 0 );
+	    	}
+	    else
+	    	{
+	    	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList Empty iDelList!" );
+	    	}
+	    RUBY_DEBUG1( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList After removal. iDelList.Count [%d]", iDelList.Count() );
+	    // If there are still more IDs, convert the next ID into a tag.
+	    if ( iDelList.Count() > 0 )
+	        {
+	        RUBY_DEBUG1( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList There are [%d] contacts to delete. Calling GetTagList for them", iDelList.Count() );
+	        iContactId = iDelList[0].iContactId;
+	        TInt retCode
+	            = iTagManager->GetTagList( this, iContext, iContactId, 0 );
+	        if ( retCode != KErrNone )
+	            {
+	            RUBY_DEBUG0( "DoRemoveNamesAfterGetTagList Failed to GetTagList, going to DoHandleEventFailedL" );
+	            TRAP_IGNORE( DoHandleEventFailedL() );      // to handle the process event failed
+	            /** @todo reengineer into single return path */
+	            // Destroy tag list
+	    		aTagList->Reset();
+	    		delete aTagList;
+	    		aTagList = 0;
+	            return;
+	            }
+	        }
+	    // If we just finished converting the last ID, move to the next phase.
+	    else{
+	        RUBY_DEBUG0( "DoRemoveNamesAfterGetTagList Moving to the next phase" );
+	        DoRemoveNamesCallDeleteTag();
+	        }
+);  // TRAPD
+if( err != KErrNone )
+	{
+	RUBY_ERROR1( "CNssContactHandlerImplementation::DoRemoveNamesAfterGetTagList Leaves with [%d] inside", err );
+	}
+		// Destroy tag list
+	    aTagList->Reset();
+	    delete aTagList;
+	    aTagList = 0;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoRemoveNamesCallDeleteTag
+// Sends the DeleteTag() calls to lower layers when removing names.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoRemoveNamesCallDeleteTag()
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoRemoveNamesCallDeleteTag. iDeleteTagListArray->Count() [%d] Setting iDeleteCallbackCounter = 0",
+iDeleteTagListArray->Count() );
+if( iDeleteTagListArray->Count() > 0 )
+	{
+	    iDeleteCallbackCounter = 0;
+	    for ( TInt k( 0 ); k < iDeleteTagListArray->Count(); k++ )
+	        {
+	        TInt ret =
+	            iTagManager->DeleteTag( this, (*iDeleteTagListArray)[k] );
+	        if ( ret != KErrNone )
+	            {
+	            TRAPD( err, DoHandleEventFailedL(); );
+	            if( err != KErrNone )
+	            	{
+	            	RUBY_ERROR1( "CNssContactHandlerImplementation::DoRemoveNamesCallDeleteTag Error handling Left with [%d]", err );
+	            	}
+	            return;  /** @todo reengineer into single return path */
+	            }
+	        }
+	} // if there are tags to delete
+else
+	{
+	// if there were no tags to delete (attempt to delete non-existing tags)
+	// simulating callback from successful deletion of.. 0 tags
+	//iDeleteCallbackCounter = -1;
+	//DeleteTagCompleted();
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesCallDeleteTag Here!" );
+	}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted
+// DeleteTag() callback calls this funciton. It counts
+// the number of callbacks, and when all callbacks have arrived,
+// goes to the next phase.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted()
+	{
+iDeleteCallbackCounter++;
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted. iDeleteCallbackCounter [%d], Count() [%d]", iDeleteCallbackCounter, iDeleteTagListArray->Count() );
+if ( iDeleteCallbackCounter == iDeleteTagListArray->Count() )
+{
+if( iNormalChangesError == KErrNone )
+	{
+	TRAPD( err, RemovingNamesCompletedL() );
+		if ( err != KErrNone )
+		{
+		RUBY_ERROR1( "CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted. Error [%d] in RemovingNamesCompletedL", err );
+		}
+	}
+else
+	{
+	// There is not much we can do about the deletion error
+	// Retrying deletion can cause endless cycle
+	// Sometimes failed deletions are ok (if we tried to delete non-existing tag)
+	/** @todo reengineer SpeechItemTrainer (and/or SRS plugin) to report deletion
+	    of non-existing tag as success. After all they are not in the DB */
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted Deletion failed. Still simulating a successful one" );
+	TRAPD( err, RemovingNamesCompletedL() );
+		if ( err != KErrNone )
+		{
+		RUBY_ERROR1( "CNssContactHandlerImplementation::DoRemoveNamesAfterDeleteTagCompleted. Error [%d] in RemovingNamesCompletedL", err );
+		}
+	}  // if (iNormalChangesError == KErrNone) else
+}  // if count
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::RemovingNamesCompletedL
+// Cleans up after some names have been removed
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::RemovingNamesCompletedL()
+{
+	RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::RemovingNamesCompletedL" );
+iDelList.Close();
+if ( iDeleteTagListArray )
+{
+iDeleteTagListArray->ResetAndDestroy();
+iDeleteCallbackCounter = 0;
+}
+DoAddNamesL();
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoAddNamesL
+// Starts name addition sequence by fetching contacts data and ordering
+// voice tags training
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoAddNamesL()
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::DoAddNamesL" );
+TInt k( 0 );
+if ( iAddList.Count() == 0 )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesL Nothing to add. Setting iState = ECHIdle. Return" );
+	SetState ( ECHIdle );
+	// If there are events on the list, DoAddNamesCompleted will fire them
+DoAddNamesCompletedL();
+}
+else
+{
+// Create new tags and train them.
+for ( k = 0; k < iAddList.Count(); k++ )
+{
+// 3 names may be created from one contact:
+//  * Main name (firstname + lastname XOR companyname)
+//  * Reversed order name (usually lastname + firstname, depends on the UI language)
+//      -> only if NSSVAS_CONTACTHANDLER_FREEORDER is defined
+//  * Nickname
+TContactData contactData;
+contactData.iID = iAddList[k].iContactId;
+contactData.iSyncTime.UniversalTime();
+// Nickname
+contactData.iTitle = NULL;
+TRAPD( err, contactData.iTitle = GetContactNicknameL( iAddList[k].iContactId ) );
+if ( contactData.iTitle != NULL )
+{
+CleanupStack::PushL( contactData.iTitle );
+contactData.iType = ETagTypeNickName;
+User::LeaveIfError( iContactQueue.Append( contactData ) );
+CleanupStack::Pop( contactData.iTitle );
+}
+// Main name ( Using GetContactTitleL() )
+contactData.iTitle = NULL;
+TBool bothFound = EFalse;
+TVasTagType tagType( ETagTypeUnknown );
+TRAP( err, contactData.iTitle = GetContactTitleL( iAddList[k].iContactId, ETrue, bothFound, tagType ) );
+// If all the name fields are empty, nothing
+// can be done for the tag. We're finished.
+if ( contactData.iTitle != NULL )
+{
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoAddNamesL For Contact id [%d] title is: [%S]", iAddList[k].iContactId, contactData.iTitle );
+CleanupStack::PushL( contactData.iTitle );
+contactData.iType = tagType;
+User::LeaveIfError( iContactQueue.Append( contactData ) );
+CleanupStack::Pop( contactData.iTitle );
+}
+#ifdef NSSVAS_CONTACTHANDLER_FREEORDER
+// Default order added previously, now adding
+// secondary order if both first and lastnames are found
+if ( bothFound )
+{
+contactData.iTitle = NULL;
+TRAPD( err, contactData.iTitle = GetContactTitleL( iAddList[k].iContactId, EFalse, bothFound, tagType ) );
+if ( contactData.iTitle != NULL )
+{
+CleanupStack::PushL( contactData.iTitle );
+contactData.iType = tagType;
+User::LeaveIfError( iContactQueue.Append( contactData ) );
+CleanupStack::Pop( contactData.iTitle );
+}
+}
+#endif // NSSVAS_CONTACTHANDLER_FREEORDER
+}
+// No tag had any text.
+if ( iContactQueue.Count() == 0 )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesL. No tag had any text, return" );
+DoAddNamesCompletedL();
+}
+else
+{
+// At least some tag has some text
+RUBY_ASSERT_DEBUG( iTagArray.Count() == 0, User::Panic( KFile, __LINE__ ) );
+for ( k = 0; k < iContactQueue.Count(); k++ )
+{
+// (1) Create a new tag
+if ( iNewTag != NULL )
+{
+// If previous call to this function leaves, iNewTag can
+// be not deleted
+delete iNewTag;
+iNewTag = NULL;
+}
+iNewTag = iTagManager->CreateTagL( iContext );
+MNssRRD* rrd = iNewTag->RRD();
+MNssSpeechItem* speechItem = iNewTag->SpeechItem();
+// (2) Fill RRD. RRD contains client-chosen data about the tag.
+//     In case of name dialing, RRD contains the contact ID,
+//     which is used later to get the phone number.
+CArrayFixFlat<TInt> *id = new (ELeave) CArrayFixFlat<TInt>( 1 );
+CleanupStack::PushL( id );
+id->AppendL( iContactQueue[k].iID ); // ID
+// select a number field for voice tag
+// TInt fieldIndex( 0 );
+		WaitUntilNoSyncBackupIsRunning();
+TRAPD( err, ReadContactL( iContactQueue[k].iID ); );
+if ( err == KErrNone )
+{
+// 1. Default voice call number set by the user
+TInt found = KErrNotFound;
+TRAP( found, iPbkHandler->FindDefaultContactFieldL( EDefaultCommand ) );
+if ( found == KErrNotFound )
+{
+for( TInt i = 0; i < KTaggableFieldsCount; i++)
+{
+TRAP( found, iPbkHandler->FindFieldL( KTaggableFields[i] ) );
+if( found == KErrNone && ( !iPbkHandler->IsFieldEmptyL() ) )
+{
+break;  // found field
+}
+else
+{
+// When field->IsEmptyOrAllSpaces(), it is the same for us as no field present
+found = KErrNotFound;
+}
+}  // for i < KTaggableFieldsCount
+}
+if ( found == KErrNone ) // found and is not empty
+{
+id->AppendL( iPbkHandler->FieldIdL() ); // field ID to array
+id->AppendL( EDial );
+id->AppendL( iContactQueue[k].iType );
+id->AppendL( EDefaultCommand );
+rrd->SetIntArrayL ( id );
+// (3) Set the training text.
+speechItem = iNewTag->SpeechItem();
+speechItem->SetTextL( *iContactQueue[k].iTitle );
+User::LeaveIfError( iTagArray.Append( iNewTag ) );
+// Leave protection for iNewTag completed
+// Ownership and deletion responsibility moved
+// to iTagArray
+iNewTag = NULL;
+}
+else
+{
+// field not found or is empty
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesL Did NOT identify a suitable voice dial field for contact id [%d]", iContactQueue[k].iID);
+delete iNewTag;
+iNewTag = NULL;
+}  // if field else
+#ifdef __SIND_EXTENSIONS
+// this part creates separate voice tags for extensions
+for ( TInt i(0); i < iExtensionList.Count(); i++ )
+{
+found = KErrNotFound;
+TVasExtensionAction action = iExtensionList[i].iAction;
+TPbkFieldId fieldId = iExtensionList[i].iId;
+// default message number
+// default video
+// default e-mail
+// default VOIP
+if ( action == ENewMessage ||
+iExtensionList[i].iId == EPbkFieldIdPhoneNumberVideo ||
+iExtensionList[i].iId == EPbkFieldIdEmailAddress ||
+iExtensionList[i].iId == EPbkFieldIdVOIP )
+{
+// @todo Should use DefaultMessageField or something similar!!
+TRAP( found,
+iPbkHandler->FindDefaultContactFieldL( iExtensionList[i].iCommand ) );
+}
+/*if ( extensionField == NULL )
+{
+extensionField = item->FindField( iExtensionList[i].iId );
+}
+if ( extensionField == NULL && field != NULL
+&& ( action == ENewMessage ) )
+{
+// if default neither default field or mobile field was not found
+// message use normal SIND field
+extensionField = field;
+fieldId = field->FieldInfo().FieldId();
+}*/
+// If field was not found, try to find it based on the priority lists
+if ( found == KErrNotFound )
+{
+found = FindExtensionField( action, iExtensionList[i].iId );
+// If field was found, check the field ID
+if ( found == KErrNone )
+{
+fieldId = iPbkHandler->FieldIdL();
+}
+}
+if ( found == KErrNone )
+{
+// create new tag
+iNewTag = iTagManager->CreateTagL( iContext );
+rrd = iNewTag->RRD();
+speechItem = iNewTag->SpeechItem();
+// set RRD data
+CArrayFixFlat<TInt> *extIds = new (ELeave) CArrayFixFlat<TInt>( 1 );
+CleanupStack::PushL( extIds );
+extIds->AppendL( iContactQueue[k].iID );
+extIds->AppendL( fieldId );
+extIds->AppendL( action );
+extIds->AppendL( iContactQueue[k].iType );
+extIds->AppendL( iExtensionList[i].iCommand );
+rrd->SetIntArrayL ( extIds );
+// set the training text.
+TPtr namePtr( iContactQueue[k].iTitle->Des() );
+TPtr extensionPtr( iExtensionList[i].iText->Des() );
+HBufC* tempTitle = HBufC::NewLC( namePtr.Length() + extensionPtr.Length() + KTrainingIndexSize );
+TPtr titlePtr( tempTitle->Des() );
+//not work: titlePtr.AppendFormat( extensionPtr, namePtr );
+titlePtr = extensionPtr;
+AppendExtensionMarker( titlePtr );
+TInt index = titlePtr.Find( KExtensionFormatString );
+if ( index >= 0 )
+{
+// replace %U with name
+titlePtr.Delete( index, 2 ); // delete %U
+titlePtr.Insert( index, namePtr );
+}
+speechItem->SetTextL( titlePtr );
+User::LeaveIfError( iTagArray.Append( iNewTag ) );
+iNewTag = NULL; //ownership changed
+CleanupStack::PopAndDestroy( tempTitle );
+CleanupStack::PopAndDestroy( extIds );
+}
+}
+#endif // __SIND_EXTENSIONS
+// delete id
+CleanupStack::PopAndDestroy( id );
+}
+else
+{
+// Opening contact failed. E.g. if it was just deleted by user
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoAddNamesL Failed to open contact id [%d]. Leave [%d]", iContactQueue[k].iID, err);
+CleanupStack::PopAndDestroy( id );
+delete iNewTag;
+iNewTag = NULL;
+/** @todo Try reengineering duplicated cleanups into single piece
+of the code */
+}
+}  // for k .. iContactQueue
+if ( iTagArray.Count() == 0 )
+{
+// If there are events on the list, DoAddNamesCompleted will fire them
+DoAddNamesCompletedL();
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesL. Returned from DoAddNamesCompleted. Setting iState = ECHIdle" );
+		SetState ( ECHIdle );
+}
+else
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesL Before training tags. TagCount = [%d]",
+	            iTagArray.Count() );
+iTrainCallbackCounter = 0;
+for ( k = 0; k < iTagArray.Count(); k++ )
+{
+MNssSpeechItem* speechItem = iTagArray[k]->SpeechItem();
+MNssSpeechItem::TNssSpeechItemResult trainRet
+= speechItem->TrainTextL( this, iTrainingParams );
+if ( trainRet != MNssSpeechItem::EVasErrorNone )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesL : TrainTextL call failed." );
+// Not much we can do except for timed retry.
+// This stops the contact handler.
+DoHandleEventFailedL();
+break;  // no processing anymore. Quit function
+}
+}  // for k < iTagArray.Count()
+}  // if iTagArrayCount != 0
+}
+}  // if ( iAddList.Count() != 0 )
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoAddNamesTrainingFinished
+// Called after training of a current pack of tags has finished.
+// Starts saving tags.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoAddNamesTrainingFinished()
+{
+iSaveCallbackCounter = 0;
+iRetry = 0; // retry, if save tag fails
+iNormalChangesError = 0; // to record failures in save tag
+DoAddNamesSaveTag();
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoAddNamesSaveTag
+// This function has two branches:
+// (1) Initiate saving tags
+// (1) After all tags have been saved, go to the next phase.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoAddNamesSaveTag()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesSaveTag" );
+TInt retCode;
+// If all tags have been saved, go to the next phase.
+if ( iSaveCallbackCounter == iTagArray.Count() )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesSaveTag All tags have been saved, go to the next phase" );
+// Tags saved - go to the next phase
+if ( iNormalChangesError == KErrNone )
+{
+// This function is called once per 100 contacts -> It is ok to use TRAP
+TRAPD( error, DoAddNamesCompletedL() );
+if( error != KErrNone )
+{
+/** @todo Test this branch */
+// Some fatal error occured
+RUBY_ERROR1( "DoAddNamesSaveTag DoAddNamesCompletedL failed with [%d]. Disabling SIND",
+error );
+DisableEventHandling();
+}
+}
+else
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesSaveTag Saving tags failed. Try again a few times" );
+// Saving tags failed. Try again a few times, and if it still
+// doesn't work, go to fatal error handler.
+if ( iRetry < KVASCHMaxRetry )
+{
+iRetry++;
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoAddNamesSaveTag Retried saving [%d] times. [%d] retries left",
+iRetry, KVASCHMaxRetry - iRetry);
+iSaveCallbackCounter = 0;
+iNormalChangesError = KErrNone;
+DoAddNamesSaveTag();
+}
+else
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesSaveTag Retried saving [%d] times. Still saving fails. Handling error", iRetry );
+NormalChangesHandleError();
+}
+}
+}  // if ( iSaveCallbackCounter == iTagArray.Count() )
+// If this is the first call to this function,
+// make "save tag" calls. After that, wait for the callbacks.
+else if ( iSaveCallbackCounter == 0 )
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesSaveTag iSaveCallbackCounter == 0. Run SaveTag for [%d] contacts",
+iTagArray.Count());
+for ( TInt k( 0 ); k < iTagArray.Count(); k++ )
+{
+retCode = iTagManager->SaveTag( this, iTagArray[k] );
+if ( retCode != KErrNone )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesSaveTag - SaveTag failed." );
+				TRAPD( err, DoHandleEventFailedL(); );
+				if( err != KErrNone )
+					{
+					RUBY_ERROR1( "CNssContactHandlerImplementation::DoAddNamesSaveTag handling error Left with [%d]", err );
+					}
+return;
+}  // if retCode
+}  // for iTagArray
+}  // else if iSaveCallbackCounter == 0
+else
+	{
+	// iSaveCallbackCounter != 0, but different from iTagArray.Count()
+	// This means, that SaveTag callbacks are still coming. We will wait for them
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesSaveTag. iSaveCallbackCounter != 0, but different from iTagArray.Count()" );
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoAddNamesSaveTagCompleted
+// Saving single tag has completed.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoAddNamesSaveTagCompleted( TInt aError )
+{
+iSaveCallbackCounter++;
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesSaveTagCompleted iSaveCallbackCounter became [%d]",
+iSaveCallbackCounter);
+	// |= to let single KErrGeneral fail any number of KErrNone
+iNormalChangesError |= aError;
+// Check if all tags have been saved.
+DoAddNamesSaveTag();
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoAddNamesCompleted
+// When adding names has successfully finished, clean up.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoAddNamesCompletedL()
+{
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoAddNamesCompleted. iDeleteCallbackCounter [%d], Count() [%d]", iDeleteCallbackCounter, iDeleteTagListArray->Count() );
+	TInt initialDeleteTagListCount = iDeleteTagListArray->Count();
+iSaveCallbackCounter = 0;
+iTrainCallbackCounter = 0;
+// DoAddNamesCompleted if often called after voice tags have been added =>
+// Nothing has to be done at all
+TBool changedDatabase = EFalse;
+#ifndef __SIND_EXTENSIONS
+// Set VAS_SETS_VOICETAG on if old behaviour is needed.
+// That is, VAS sets on the voice tag field to Phonebook engine and Phonebook UI checks the contacts DB for voice tags.
+// Off means that VAS does not set voice tag field but instead Phonebook asks from VAS.
+#ifdef VAS_SETS_VOICETAG
+// add voice tag fields
+// iTagArray contains only successfully trained tags.
+// Failed items are removed.
+for ( TInt i( 0 ); i < iTagArray.Count(); i++ )
+{
+MNssRRD* rrd = iTagArray[i]->RRD();
+CArrayFixFlat<TInt>* intArray = rrd->IntArray();
+RUBY_ASSERT_DEBUG( intArray->Count() >= 2, User::Panic( KFile, __LINE__ ) );
+if ( intArray->Count() >= 2 )
+{
+TBool committed( EFalse ); // ETrue if contact is committed already
+TInt contactId( intArray->At( 0 ) );
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesCompleted. Working on contact id [%d]",
+contactId);
+TInt fieldId( intArray->At( 1 ) );
+WaitUntilNoSyncBackupIsRunning();
+// Open contact item based on id
+TRAPD( errFor,
+OpenContactL( contactId );
+RUBY_DEBUG1( "DoAddNamesCompleted Opened contact [%d]", contactId );
+			TInt found == KErrNotFound;
+			TRAP( found, iPbkHandler->FindDefaultContactFieldL( EDefaultCommand ) );
+if ( found == KErrNotFound )
+{
+TRAP( found, iPbkHandler->FindFieldL( fieldId ) );
+}
+					// field - field, that SHOULD have voice tag attached
+if ( found == KErrNone )
+{
+TRAP( error, iPbkHandler->ChangeVoiceTagFieldL( ETrue ) );
+if ( error == KErrNone )
+{
+RUBY_DEBUG1("DoAddNamesCompleted  Successfully added icon to the contact [%d]",
+contactId);
+iPbkHandler->CloseContactL( ETrue );
+RUBY_DEBUG1("DoAddNamesCompleted  Successfully committed contact [%d]",
+contactId);
+iVoiceTagAddedList.Append( contactId );
+changedDatabase = ETrue;
+committed = ETrue;
+}
+}
+else
+{
+// field not found anymore
+RUBY_DEBUG2("DoAddNamesCompleted Field [%d] not found in (already deleted from?) contact [%d]",
+fieldId, contactId );
+iDeleteTagListArray->AppendL( NULL ); // One DeleteTag will generate one callback
+iTagManager->DeleteTag( this, iTagArray[i] );
+}
+if ( !committed )
+{
+RUBY_DEBUG1("DoAddNamesCompleted Did not change contact [%d]. Closing without committing",
+	            contactId);
+iPbkHandler->CloseContactL( EFalse );
+}
+);  // TRAPD errFor
+if ( errFor != KErrNone )
+{
+RUBY_DEBUG2("CNssContactHandlerImplementation::DoAddNamesCompleted Failed to add icon for contact [%d]. Error [%d]",
+contactId, errFor);
+// voice tag was not in the contacts database, delete it from VAS
+// One DeleteTag will generate one callback
+iDeleteTagListArray->AppendL( NULL );
+iTagManager->DeleteTag( this, iTagArray[i] );
+}
+}  // if intArray->Count() >= 2
+}  // for  iTagArray
+#endif // VAS_SETS_VOICETAG
+#endif //__SIND_EXTENSIONS
+iTagArray.ResetAndDestroy();
+iAddList.Close();
+#ifndef __SIND_EXTENSIONS
+#ifdef VAS_SETS_VOICETAG
+// Remove voice tag icons for contacts, that failed to be trained or saved
+for( TInt l = 0 ; l < iRemoveIconList.Count(); l++ )
+{
+WaitUntilNoSyncBackupIsRunning();
+TRAPD( error, OpenContactL( iRemoveIconList[l] ) );
+if ( error != KErrNone )
+{
+RUBY_DEBUG2( "CNssContactHandlerImplementation::DoAddNamesCompleted Failed to open contact [%d]. Error [%d]", iRemoveIconList[l], error);
+}
+else
+{
+TRAP( error, iPbkHandler->ChangeVoiceTagFieldL( EFalse ) );
+if ( error == KErrNotFound )
+{
+// Nothing to remove. Already no voice tag icon
+TRAP( error, iPbkHandler->CloseContactL( EFalse ) );
+if ( error != KErrNone )
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::DoAddNamesCompleted Failed to close contact [%d]. Error [%d]", iRemoveIconList[l], error);
+}
+}
+else if ( error != KErrNone )
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::DoAddNamesCompleted  Failed to remove voice tag icon for contact [%d]. Error [%d]", iRemoveIconList[l], error);
+TRAP( error, iPbkHandler->CloseContactL( EFalse ) );
+if ( error != KErrNone )
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::DoAddNamesCompleted Failed to close contact [%d]. Error [%d]", iRemoveIconList[l], error);
+}
+}
+else
+{
+iVoiceTagAddedList.Append( iRemoveIconList[l] );
+TRAP( error, iPbkHandler->CloseContactL( ETrue ) );
+if ( error != KErrNone )
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::DoAddNamesCompleted Failed to commit contact [%d]. Error [%d]", iRemoveIconList[l], error);
+}
+}
+}  // if opened contact successfully
+}
+#endif // VAS_SETS_VOICETAG
+#endif //__SIND_EXTENSIONS
+iRemoveIconList.Close();
+for( TInt k( 0 ); k < iContactQueue.Count(); k++ )
+{
+delete iContactQueue[k].iTitle;
+iContactQueue[k].iTitle = NULL;
+}
+iContactQueue.Close();
+if( changedDatabase )
+	{
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesCompleted changed DBx" );
+	WaitUntilNoSyncBackupIsRunning();
+	    TRAPD(err, iPbkHandler->CompressL() );
+	    if ( err )
+		{
+		RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesCompleted Contacts DB compression failed. Error [%d]",
+		            err);
+		}
+	}
+else
+	{
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesCompleted did NOT change DB" );
+	}
+	// full resyncs are always tag additions
+if( initialDeleteTagListCount == iDeleteTagListArray->Count() )
+	{
+	SetState( ECHIdle );
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesCompleted Syncing with phonebook generated NO deletions" );
+	// then full resync will not be initiated
+	iConsecutiveErrorFullResync = 0;
+	    if ( iEventArray.Count() > 0 )
+	{
+		RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesCompleted There are still [%d] events in the queue. Call DoHandleEvents for them",
+		            iEventArray.Count() );
+	TRAPD( err, DoHandleEventsL() );
+	if ( err != KErrNone )
+	            {
+	            RUBY_ERROR1( "CNssContactHandlerImplementation::DoAddNamesCompleted. Error [%d] in DoHandleEventsL", err );
+	}
+	}
+	else
+		{
+		// No self-generated events, and no pending events to handle
+		// This is the only place in the code, where everything is completed
+		// and nothing is pending
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesCompleted All the updates completed. No DB event is pending" );
+		}
+	}
+else
+	{
+	RUBY_DEBUG1( "CNssContactHandlerImplementation::DoAddNamesCompleted Generated [%d] deletions. Starting to wait for callbacks",
+		iDeleteTagListArray->Count() - initialDeleteTagListCount);
+	}
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DoAddNamesCompleted completed" );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::NormalChangesHandleError
+// Handle errors which happend when updating normal changes
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::NormalChangesHandleError()
+{
+// We can't know, what went wrong.
+// Stop contact handler, so that the next time the phone is booted
+// full synchronization happens.
+RUBY_DEBUG0( "CNssContactHandlerImplementation::NormalChangesHandleError " );
+TRAPD( err, DoHandleEventFailedL(); );
+if( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::NormalChangesHandleError DoHandleEventFailedL Left with [%d]", err );
+}
+}
+//---------------------------------------------------------
+// CNssContactHandlerImplementation::HandleTrainComplete
+// Saves the tag after successful training.
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::HandleTrainComplete( TInt aErrorCode )
+{
+if( aErrorCode == KErrNone )
+{
+RUBY_DEBUG1( "Training OK for %d:th name.", iTrainCallbackCounter );
+RUBY_DEBUG1( "CNssContactHandlerImplementation::HandleTrainComplete. iState [%d]", iState);
+RUBY_ASSERT_DEBUG( iState == ECHInitializing ||
+iState == ECHHandlingNormalChanges,
+User::Panic( KFile, __LINE__ ) );
+iTrainCallbackCounter++;
+if ( iTrainCallbackCounter == iTagArray.Count() )
+{
+if ( iState != ECHInitializing )
+{
+// assert at the beginning of the function guarantees,
+// that iState == ECHHandlingNormalChanges
+DoAddNamesTrainingFinished();
+}
+}
+}
+else // aErrorCode != KErrNone
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::HandleTrainComplete. Training failed for %d:th name.\n",
+iTrainCallbackCounter );
+RUBY_ASSERT_DEBUG( iState == ECHInitializing ||
+iState == ECHHandlingNormalChanges,
+User::Panic( KFile, __LINE__ ) );
+	// Order removal of voice tag icon if present
+	MNssRRD* rrd = iTagArray[iTrainCallbackCounter]->RRD();
+CArrayFixFlat<TInt>* intArray = rrd->IntArray();
+RUBY_ASSERT_DEBUG( intArray->Count() >= 2, User::Panic( KFile, __LINE__ ) );
+if ( intArray->Count() >= 2 )
+	{
+	TInt error = iRemoveIconList.Append( intArray->At(0) );
+	if( error != KErrNone )
+		{
+		RUBY_ERROR2( "CNssContactHandlerImplementation::HandleTrainError Failed to insert [%d] into iRemoveIconList. Error [%d]",
+					intArray->At(0), error);
+		}
+}
+	else
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::HandleTrainComplete rrd->IntArray()->Count [%d] for iTrainCallbackCounter [%d]",
+			intArray->Count(), iTrainCallbackCounter);
+}
+delete iTagArray[ iTrainCallbackCounter ];
+iTagArray.Remove( iTrainCallbackCounter );
+if ( iTrainCallbackCounter == iTagArray.Count() )
+{
+if ( iState == ECHHandlingNormalChanges )
+{
+DoAddNamesTrainingFinished();
+}
+else
+	{
+	RUBY_ERROR1( "CNssContactHandlerImplementation::HandleTrainComplete Unexpected state [%d]", iState);
+	}
+}
+}
+}
+//---------------------------------------------------------
+// CNssContactHandlerImplementation::HandleTrainError
+// Handles single tag training failure
+//---------------------------------------------------------
+//
+/*void CNssContactHandlerImplementation::HandleTrainError( enum MNssTrainTextEventHandler::TNssTrainResult )
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::HandleTrainError Training failed for %d:th name.\n",
+iTrainCallbackCounter );
+RUBY_ASSERT_DEBUG( iState == ECHInitializing ||
+iState == ECHHandlingNormalChanges,
+User::Panic( KFile, __LINE__ ) );
+	// Order removal of voice tag icon if present
+	MNssRRD* rrd = iTagArray[iTrainCallbackCounter]->RRD();
+CArrayFixFlat<TInt>* intArray = rrd->IntArray();
+RUBY_ASSERT_DEBUG( intArray->Count() >= 2, User::Panic( KFile, __LINE__ ) );
+if ( intArray->Count() >= 2 )
+	{
+	TInt error = iRemoveIconList.Append( intArray->At(0) );
+	if( error != KErrNone )
+		{
+		RUBY_ERROR2( "CNssContactHandlerImplementation::HandleTrainError Failed to insert [%d] into iRemoveIconList. Error [%d]",
+					intArray->At(0), error);
+		}
+}
+	else
+{
+RUBY_ERROR2( "CNssContactHandlerImplementation::HandleTrainError rrd->IntArray()->Count [%d] for iTrainCallbackCounter [%d]",
+			intArray->Count(), iTrainCallbackCounter);
+}
+delete iTagArray[ iTrainCallbackCounter ];
+iTagArray.Remove( iTrainCallbackCounter );
+if ( iTrainCallbackCounter == iTagArray.Count() )
+{
+if ( iState == ECHHandlingNormalChanges )
+{
+DoAddNamesTrainingFinished();
+}
+else
+	{
+	RUBY_ERROR1( "CNssContactHandlerImplementation::HandleTrainError Unexpected state [%d]", iState);
+	}
+}
+}*/
+//---------------------------------------------------------
+// CNssContactHandlerImplementation::FullResyncStart
+// Starts a full synchronization
+//---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::FullResyncStart()
+{
+// If we have synchronized earlier, we must delete the old context.
+if ( iHaveWeEverSynced )
+{
+iContextManager->DeleteContext( this, iContext );
+}
+else
+{
+TRAPD( err, FullResyncCreateContextL() );
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::FullResyncStart. Error [%d] in FullResyncCreateContextL", err );
+}
+}
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::FullResyncCreateContextL
+// Full resync: Create a new context
+// (prev: Destroy old context, next:populate the context with tags)
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::FullResyncCreateContextL()
+{
+RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::FullResyncCreateContextL" );
+if ( iContext != 0 )
+{
+delete iContext;
+iContext = 0;
+}
+iContext = iContextManager->CreateContextL();
+iContext->SetNameL( KNssCHNameDialContext );
+iContext->SetGlobal( ETrue );
+TBuf8<KClientDataSize> clientDataBuf;
+iClientData.iLanguage = User::Language();
+iClientData.iContactSyncId = KErrNotFound;
+TRAPD( error, iClientData.ExternalizeL( clientDataBuf ) );
+if ( !error )
+{
+iContext->SetClientData( clientDataBuf );
+iContextManager->SaveContext( this, iContext );
+}
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::FullResyncCreateChanges
+// Create tags and send training requests to VAS.
+// VAS trains them and calls back when it's ready
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::FullResyncCreateChangesL()
+{
+	RUBY_DEBUG_BLOCK( "CNssContactHandlerImplementation::FullResyncCreateChangesL" );
+WaitUntilNoSyncBackupIsRunning();
+CContactIdArray* ids = iPbkHandler->ContactIdArrayLC();
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::FullResyncCreateChanges. iContactQueue.Count() == 0" );
+RUBY_ASSERT_DEBUG( iContactQueue.Count() == 0, User::Panic( KFile, __LINE__ ) );
+// Create change events for training
+for ( TInt k( 0 ); k < ids->Count(); k++ )
+{
+TPhonebookEvent event;
+event.iContactId = (*ids)[k];
+event.iType = EContactAdded;
+iEventArray.Append( event );
+}
+CleanupStack::PopAndDestroy( ids ); // Cleanup stack: empty
+// go to processing events
+SetState ( ECHIdle );
+TRAPD( err, DoHandleEventsL() );
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::FullResyncCreateChanges. Error [%d] in DoHandleEventsL", err );
+}
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::DeleteContextCompleted
+// DeleteContext callback. Deleting a context is part of
+// full synchronization.
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DeleteContextCompleted( TInt aErrorCode )
+{
+if( aErrorCode == KErrNone )
+{
+// Go to the next phase of full synchronization
+RUBY_DEBUG1( "CNssContactHandlerImplementation::DeleteContextCompleted. iState == ECHFullResync, iState [%d]", iState );
+RUBY_ASSERT_DEBUG( iState == ECHFullResync, User::Panic( KFile, __LINE__ ) );
+TRAPD( err, FullResyncCreateContextL() );
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::DeleteContextCompleted. Error [%d] in FullResyncCreateContextL", err );
+}
+}
+else
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DeleteContextCompleted failed" );
+RUBY_ASSERT_DEBUG( iState == ECHFullResync, User::Panic( KFile, __LINE__ ) );
+RUBY_DEBUG0( "CNssContactHandlerImplementation::DeleteContextCompleted - can't handle, stopping." );
+	TRAPD( err, DoHandleEventFailedL(); );
+	if( err != KErrNone )
+		{
+		RUBY_ERROR1( "CNssContactHandlerImplementation::DeleteContextCompleted Left with [%d]", err);
+		}
+}
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::CausedByVoiceTagAddition
+// Check if the event was caused by voice tag field adding
+// ------------------------------------------------------------
+//
+TBool CNssContactHandlerImplementation::CausedByVoiceTagAddition( const TPhonebookEvent& aEvent )
+	{
+	TBool isVoiceTagAddedEvent (EFalse);
+	if( EContactChanged == aEvent.iType )
+		{
+		for ( TInt i = 0; i < iVoiceTagAddedList.Count(); i++ )
+	{
+	if ( aEvent.iContactId == iVoiceTagAddedList[i] )
+		{
+	isVoiceTagAddedEvent = ETrue;
+	iVoiceTagAddedList.Remove( i-- );  // "i--" because of removal
+	// Continue iterations. We are not sure if voice tag for the given
+	// contact could be changed twice
+	}
+	}  // for
+		}  // if event type
+	return isVoiceTagAddedEvent;
+	}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::PeriodicCallback
+// Static callback required by Symbian Timer services.
+// ------------------------------------------------------------
+//
+TInt CNssContactHandlerImplementation::PeriodicCallback( TAny* pX )
+	{
+	((CNssContactHandlerImplementation*)pX)->DoPeriodicCallback();
+	return KErrNone;  // useless for CPeriodic
+	}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::DoPeriodicCallback
+// Periodically check if there are some events to process
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoPeriodicCallback()
+	{
+	RUBY_DEBUG0( "CNssContactHandlerImplementation::DoPeriodicCallback" );
+	// Check is needed to eliminate unnesessary TRAP and 64 bit time operations
+	// Note, that we are not checking for PeriodicAction(), but for iPeriodicHandleEventTimer == NULL
+	// PeriodicAction() is a method for detection of start of the action,
+	// while iPeriodicHandleEventTimer == NULL says if periodic action is being executed
+	// right *now*
+	if ( ( iState == ECHIdle ) && ( iEventArray.Count() > 0 ) && ( !PeriodicAction() ) )
+		{
+		RUBY_DEBUG1( "CNssContactHandlerImplementation::DoPeriodicCallback. iState is ECHIdle, there are [%d] events to handle and no periodic action in progress", iEventArray.Count());
+		TRAPD( err, DoHandleEventsL());
+if ( err != KErrNone )
+{
+RUBY_ERROR1( "CNssContactHandlerImplementation::DoPeriodicCallback. Error [%d] in DoHandleEventsL", err );
+}
+}  // if there are some events
+	else
+		{
+		RUBY_DEBUG0( "CNssContactHandlerImplementation::DoPeriodicCallback No events to handle"  );
+		}
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::PeriodicAction
+// Detects periodic action.
+// Checks if many events have been received "lately"
+// ---------------------------------------------------------
+//
+TBool CNssContactHandlerImplementation::PeriodicAction()
+{
+// index of the first recorded call
+TInt checkedIndex = iEventMomentIndex + 1;
+checkedIndex = checkedIndex < KEventMomentsSize ? checkedIndex : 0;
+TTime& checkedTime = iEventMoments[checkedIndex];
+// Check if the first recorded call happened "lately" = within last
+// KPeriodicActionInterval seconds
+TTime currentTime;
+currentTime.UniversalTime();
+TTimeIntervalMicroSeconds diff = currentTime.MicroSecondsFrom( checkedTime );
+TBool result = diff < iEndOfPeriodicActionInterval;
+if ( result == EFalse )
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::PeriodicAction. Periodic action completed." );
+RUBY_DEBUG2( "CNssContactHandlerImplementation::PeriodicAction. Periodic action completed. iEventMomentIndex [%d], checkedIndex [%d]", iEventMomentIndex, checkedIndex );
+RUBY_DEBUG1( "currentTime [%d]", I64INT(currentTime.Int64()));
+RUBY_DEBUG2( "CNssContactHandlerImplementation::PeriodicAction. diff [%d], iEndOfPeriodicActionInterval [%d]", I64INT(diff.Int64()), I64INT(iEndOfPeriodicActionInterval.Int64() ) );
+for( TInt i = 0; i < KEventMomentsSize; i++ )
+{
+RUBY_DEBUG2( "checkedIndex[%d] = [%d]", i, I64INT(iEventMoments[i].Int64() ) );
+}
+// Periodic action completed. Or hasn't even been started
+// Restore timeout values
+// iEndOfPeriodicActionInterval = KInitialPeriodicActionInterval;
+if ( iPeriodicHandleEventTimer != NULL )
+{
+// stop the timer, it was started, when periodic action was started
+RUBY_DEBUG0( "CNssContactHandlerImplementation::PeriodicAction Stopping the periodic action timer" );
+iPeriodicHandleEventTimer->Cancel();
+delete iPeriodicHandleEventTimer;
+iPeriodicHandleEventTimer = NULL;
+}
+}
+else
+{
+// Periodic action detected
+// start the timer if it is not running yet
+if( iPeriodicHandleEventTimer == NULL )
+{
+TRAPD( err, iPeriodicHandleEventTimer = CPeriodic::NewL( EPriorityNormal ) );
+if( err != KErrNone )
+{
+// This is a bad situation, but not the fatal one.
+// If we cannot use timer to detect end of periodic action,
+// Let's disable periodic action detection at all
+RUBY_DEBUG1( "CNssContactHandlerImplementation::PeriodicAction. PeriodicTimer creation failed. Error [%d]. Disabling periodic actions", err);
+result = EFalse;
+}
+else
+{  // Timer was created successfully
+RUBY_DEBUG0( "CNssContactHandlerImplementation::PeriodicAction Starting the periodic action timer" );
+iPeriodicHandleEventTimer->Start( KPeriodicTimerInterval, KPeriodicTimerInterval, TCallBack( PeriodicCallback, this ) );
+}
+}
+}
+return result;
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::UpdatePeriodicActionVars
+// Update variables, used to detect if periodic action is happening
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::UpdatePeriodicActionVars()
+{
+if ( ++iEventMomentIndex >= KEventMomentsSize )
+{
+iEventMomentIndex = 0;
+}
+iEventMoments[iEventMomentIndex].UniversalTime();
+// Update values used to detect end of periodic action
+TTimeIntervalMicroSeconds32 currInterval = MaximalInterval( iEventMoments, KEventMomentsSize, iEventMomentIndex );
+// 8 times. At the end of action, this would typically be no longer, than 0.5secs
+// Note, that this is the interval fo KEventMomentsSize events
+if ( ( currInterval.Int() << 3 ) >= ( KInitialPeriodicActionInterval ) )
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::UpdatePeriodicActionVars. Calculated interval is too big. Reverting periodic interval to the max [%d] mcs", KInitialPeriodicActionInterval);
+iEndOfPeriodicActionInterval = KInitialPeriodicActionInterval;
+}
+else
+{
+currInterval = currInterval.Int() << 3;
+RUBY_DEBUG1( "CNssContactHandlerImplementation::UpdatePeriodicActionVars. Adjusting periodic interval to [%d] mcs", currInterval.Int() );
+iEndOfPeriodicActionInterval = currInterval.Int();
+}
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::MaximalInterval
+// Return maximal interval from the array of time moments
+// ------------------------------------------------------------
+//
+TTimeIntervalMicroSeconds32 CNssContactHandlerImplementation::MaximalInterval( const TTime aMoments[], const TInt aMomentsLength, const TInt aLastMomentIndex )
+{
+RUBY_ASSERT_DEBUG( aMomentsLength > 1, User::Panic( KFile, __LINE__ ) );
+TInt currIndex( aLastMomentIndex );
+TInt prevIndex = currIndex - 1 < 0 ? aMomentsLength - 1 : currIndex - 1;
+TTimeIntervalMicroSeconds32 result( 0 );
+TTimeIntervalMicroSeconds currInterval;
+for ( TInt i = 0; i < aMomentsLength - 1; i++ )
+{
+currInterval = aMoments[currIndex].MicroSecondsFrom( aMoments[prevIndex] );
+const TInt64& currIntVal = currInterval.Int64();
+TBool tooBigValue = currIntVal > KMaxTInt;
+// if high != 0, aMoments were filled in the incorrect way
+// but we should not bug the user about it
+if ( tooBigValue )
+{
+// this cannot be a negative value.. if moments are recorded in the correct order.
+// Then non-zero high means, that interval is too big to fit into
+// TTimeIntervalMicroSeconds32
+RUBY_DEBUG0( "CNssContactHandlerImplementation::MaximalInterval. Maximal interval is out of bounds" );
+result = TTimeIntervalMicroSeconds32( KMaxTInt );
+break;
+}
+else
+{
+// normal size value
+// casting is safe - we checked, that it fits into TInt
+TTimeIntervalMicroSeconds32 currInterval32 ( (TInt)currIntVal );
+if ( currInterval32 > result )
+{
+result = currInterval32;
+}
+}
+currIndex = currIndex - 1 < 0 ? aMomentsLength - 1 : currIndex - 1;
+prevIndex = currIndex - 1 < 0 ? aMomentsLength - 1 : currIndex - 1;
+}  // for
+return result;
+}
+// ------------------------------------------------------------
+// CNssContactHandlerImplementation::SetState
+// Sets the contact handler state.
+// In debug, panics (via asserts) if state change is not legal
+// ------------------------------------------------------------
+//
+void CNssContactHandlerImplementation::SetState( TContactHandlerState aState )
+	{
+RUBY_DEBUG2( "CNssContactHandlerImplementation::SetState from [%d] to [%d]", iState, aState);
+switch( aState )
+{
+case ECHFullResync:
+// no pending events
+RUBY_ASSERT_DEBUG( ( iDeleteTagListArray == NULL ) || ( iDeleteCallbackCounter == iDeleteTagListArray->Count() ), User::Panic( KFile, __LINE__ ) );
+RUBY_ASSERT_DEBUG( iSaveCallbackCounter == iTagArray.Count(), User::Panic( KFile, __LINE__ ) );
+// full resyncronization needed again if this full resyncronization fails
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( ETrue ) );
+break;
+case ECHHandlingNormalChanges:
+RUBY_ASSERT_DEBUG( iState == ECHIdle, User::Panic( KFile, __LINE__ ) );
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( ETrue ) );
+break;
+case ECHIdle:
+if ( iDeleteTagListArray != NULL )
+{
+RUBY_ASSERT_DEBUG( (iSaveCallbackCounter == iTagArray.Count() ) || ( iDeleteCallbackCounter == iDeleteTagListArray->Count() ), User::Panic( KFile, __LINE__ ) );
+}
+else
+{
+RUBY_ASSERT_DEBUG( ( iSaveCallbackCounter == iTagArray.Count() ) , User::Panic( KFile, __LINE__ ) );
+}
+if( iEventArray.Count() == 0 )
+{
+// Idle state and no pending events mean, that contact handler
+// completed its operations for now
+TInt errProp = iBusyProperty.Set( EContactsNoTraining );
+if ( errProp != KErrNone )
+{
+RUBY_ERROR1("CNssContactHandlerImplementation::ConstructL() Failed to set property. Error [%d]",
+errProp );
+// @todo Not a leaving function -> leave commented out
+//User::Leave( errProp )  ;
+}
+}
+// all changes done, no need for resyncronization
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( EFalse ) );
+break;
+default:
+RUBY_ERROR0( "CNssContactHandlerImplementation::SetState Unexpected or unknown state" );
+RUBY_ASSERT_DEBUG( EFalse, User::Panic( KFile, __LINE__ ) );
+// failure, full resyncronization needed
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( ETrue ) );
+break;
+}
+// actually switch state
+iState = aState;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DataSyncStateChanged
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DataSyncStateChanged( TBool aRunning )
+{
+if( !aRunning && ( iSyncBackupWaiter->IsStarted() ) )
+{
+RUBY_DEBUG0( "DataSyncStateChanged Sync became inactive and CH was waiting for it" );
+iSyncBackupWaiter->AsyncStop();
+}
+}
+// ---------------------------------------------------------
+//  Is called when backup/restore status is changed and when backup/restore
+//  state observation was just started
+//  @param aRunning ETrue if some backup/restore action is in progress
+//                  EFalse otherwise
+//  @param aRestoreType ETrue if the event is restore related
+//                      EFalse if the event is backup related
+//  @see CNssChBackupObserver
+// ---------------------------------------------------------
+void CNssContactHandlerImplementation::BackupRestoreStateChanged( TBool aRestoreType,
+TBool aRunning )
+	{
+RUBY_DEBUG2( "BackupRestoreStateChanged aRestoreType [%d], aRunning [%d]",
+aRestoreType, aRunning );
+if( aRestoreType && aRunning )
+{
+RUBY_DEBUG0( "Setting the Full Resync CR flag" );
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( ETrue ) );
+}
+if( !aRunning && ( iSyncBackupWaiter->IsStarted() ) )
+{
+RUBY_DEBUG0( "BackupRestoreStateChanged b/r became inactive and CH was waiting for it" );
+iSyncBackupWaiter->AsyncStop();
+}
+	}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::HandleNotifyInt
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::HandleNotifyInt( TUint32 aId, TInt aNewValue )
+{
+RUBY_DEBUG0( "" );
+if ( aId == KSRSFFullResyncNeeded )
+{
+if ( aNewValue == KImmediateResync )
+{
+RUBY_DEBUG0( "Immediate full resync requested" );
+// Write the previous value back to the cenrep
+TRAP_IGNORE( SetFullResyncCrFlagL( iResyncAtBoot ) );
+// Create an event that will launch full resync
+TPhonebookEvent event;
+event.iType = ENullEvent;
+event.iContactId = 0;
+iEventArray.Append( event );
+// Start resync if nothing is ongoing
+if ( iState == ECHIdle )
+{
+TRAP_IGNORE( DoHandleEventsL() );
+}
+}
+}
+}
+// ---------------------------------------------------------
+// Sets the central repository full resync flag
+// ---------------------------------------------------------
+void CNssContactHandlerImplementation::SetFullResyncCrFlagL( TBool aResyncNeeded )
+{
+RUBY_DEBUG_BLOCKL("");
+User::LeaveIfError( iRepository->Set( KSRSFFullResyncNeeded, aResyncNeeded ) );
+iResyncAtBoot = aResyncNeeded;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::WaitUntilNoSyncBackupIsRunning
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::WaitUntilNoSyncBackupIsRunning()
+{
+RUBY_DEBUG0( "WaitUntilNoSyncBackupIsRunning start" );
+RUBY_ASSERT_DEBUG( !iSyncBackupWaiter->IsStarted(), User::Panic( KFile, __LINE__ ) );
+// Disconnection from phonebook should happen only once and only if b/r is running
+TBool disconnectedFromPb = EFalse;
+// Check the values until both data sync and backup/restore are not active
+while( iDataSyncWatcher->InProgress() || iBackupObserver->InProgress() )
+	{
+	RUBY_DEBUG2( "WaitUntilNoSyncBackupIsRunning Have to wait. data sync [%d], backup/restore [%d]",
+				 iDataSyncWatcher->InProgress(), iBackupObserver->InProgress() );
+	if( !iSyncBackupWaiter->IsStarted() )
+{
+if( (!disconnectedFromPb) && iBackupObserver->InProgress() )
+	{
+	RUBY_DEBUG0( "WaitUntilNoSyncBackupIsRunning Disconnecting from phonebook" );
+	DisconnectFromPhonebook();
+	disconnectedFromPb = ETrue;
+	}
+iSyncBackupWaiter->Start();
+}
+else
+{
+RUBY_ERROR0( "WaitUntilNoSyncBackupIsRunning Attempt to start already active iSyncBackupWaiter. Huge error!" );
+}
+	}
+if( disconnectedFromPb )
+	{
+	RUBY_DEBUG0( "WaitUntilNoSyncBackupIsRunning Reconnecting to phonebook" );
+	TRAP_IGNORE( ConnectToPhonebookL() );
+	}
+RUBY_DEBUG0( "WaitUntilNoSyncBackupIsRunning end" );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::GetContactL
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::GetContactL( TContactItemId aContactId, TBool aReadContact )
+{
+RUBY_DEBUG1( "CNssContactHandlerImplementation::GetContactL. contact id [%d]", aContactId );
+TInt err = KErrNone;
+// Number of attempts tries
+TInt attemptsTried( 0 );
+do
+{
+if( err == KErrInUse ) // i.e. not the first cycle iteration
+{
+RUBY_DEBUG2( "GetContactL Contact [%d] is locked. Waiting one more second. Retrial [%d]",
+aContactId, attemptsTried);
+// start periodic timer
+if( attemptsTried == 1)   // i.e exactly the second cycle iteration
+{
+RUBY_DEBUG0( "GetContactL Creating periodic timer" );
+iContactWaitTimer = CPeriodic::NewL( EPriorityNormal );
+iContactWaitTimer->Start( KContactWaitInterval, KContactWaitInterval, TCallBack( ContactWaitCallback, this ) );
+}
+RUBY_DEBUG0( "GetContactL Starting the inner cycle waiting" );
+iContactWaiter->Start( );
+RUBY_DEBUG0( "GetContactL Waiting completed, trying to open contact again" );
+}
+TRAP( err, iPbkHandler->FindContactL( aContactId, aReadContact ) );
+attemptsTried++;
+// -1 means forever
+if( ( KMaxContactLockRetrials != -1 ) && ( attemptsTried >= KMaxContactLockRetrials ) )
+{
+RUBY_DEBUG1( "GetContactL Tried for [%d] times, still no success", attemptsTried );
+break;
+}
+}
+while( err == KErrInUse );
+if( iContactWaitTimer != NULL )
+{
+iContactWaitTimer->Cancel();
+delete iContactWaitTimer;
+iContactWaitTimer = NULL;
+}
+// Propagate all the leaves, BUT KErrInUse
+if( ( err != KErrInUse ) && ( err != KErrNone ) )
+{
+User::LeaveIfError( err );
+}
+if( err == KErrInUse )
+{
+RUBY_DEBUG1( "GetContactL Failed to lock contact [%d]. Disabling CH, will resync on reboot", aContactId );
+DisableEventHandling();
+User::Leave( KErrInUse );
+}
+RUBY_DEBUG0( "CNssContactHandlerImplementation::GetContactL completed" );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::ReadContactL
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::ReadContactL( TContactItemId aContactId )
+{
+GetContactL( aContactId, ETrue );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::OpenContactL
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::OpenContactL( TContactItemId aContactId )
+{
+GetContactL( aContactId, EFalse );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::ContactWaitCallback
+//
+// ---------------------------------------------------------
+//
+TInt CNssContactHandlerImplementation::ContactWaitCallback( TAny* pX )
+{
+	((CNssContactHandlerImplementation*)pX)->DoContactWaitCallback();
+	return KErrNone;  // useless for CPeriodic
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::DoContactWaitCallback
+//
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::DoContactWaitCallback()
+{
+iContactWaiter->AsyncStop();
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::NoDiskSpace
+// Checks if there is not enough disk space to finish the
+// operation. Returns ETrue if there is no space.
+// ---------------------------------------------------------
+//
+TBool CNssContactHandlerImplementation::NoDiskSpace()
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::NoDiskSpace" );
+TBool diskSpace( EFalse );
+TRAP_IGNORE( diskSpace = SysUtil::FFSSpaceBelowCriticalLevelL( &iFSession, KIncreaseOfDatabaseSizes ) );
+if ( diskSpace )
+{
+RUBY_TRAP_IGNORE( SetFullResyncCrFlagL( ETrue ) );
+RUBY_DEBUG0( "CNssContactHandlerImplementation::NoDiskSpace NOT enough disk space available" );
+return ETrue;
+}
+else
+{
+RUBY_DEBUG0( "CNssContactHandlerImplementation::NoDiskSpace There is enough disk space" );
+return EFalse;
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::TrimName
+// Substitutes separator characters in descriptor with
+// white spaces. Removes extra withspaces.
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::TrimName( HBufC* aBuf )
+{
+TPtr ptr = aBuf->Des();
+for ( TInt findIndex = 0; findIndex < aBuf->Des().Length(); findIndex++ )
+{
+if ( ptr[findIndex] == iSeparator )
+{
+ptr[findIndex] = ' ';
+}
+}
+ptr.TrimAll();
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::AppendName
+// Appends name to given buffer
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::AppendName( HBufC* aBuf, HBufC* aName )
+{
+if ( aName->Length() != 0 )
+{
+aBuf->Des().Append( iSeparator );
+aBuf->Des().Append( KNameTrainingIndex );
+aBuf->Des().Append( aName->Des() );
+}
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::AppendExtensionMarker
+// Appends marker for the extensions
+// Parameters should be in format "%U text message"
+// In which case output is "%U_2text message"
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::AppendExtensionMarker( TDes& aDes )
+{
+if ( aDes.Length() > 0 )
+{
+TInt insertPosition( 0 );
+if ( aDes.Find( KExtensionFormatString ) == 0 )
+{
+// Find the first space and insert marker to that position
+TInt firstSpace( 0 );
+firstSpace = aDes.Find( _L(" ") );
+if ( firstSpace == 2 )         // Next character after KExtensionFormatString
+{
+aDes.Delete( firstSpace, 1 );
+}
+insertPosition = 2;
+}
+// Insert marker
+aDes.Insert( insertPosition, KExtensionTrainingIndex );
+aDes.Insert( insertPosition, KNameSeparator );
+}
+}
+/**
+* Establishes the connection to the contact engine and
+* starts listening to it
+*/
+void CNssContactHandlerImplementation::ConnectToPhonebookL()
+	{
+	RUBY_ASSERT_DEBUG( (!iPbkHandler), User::Leave( KErrNotReady ) );
+	iPbkHandler = CVasVPbkHandler::NewL();
+	iPbkHandler->InitializeL();
+	iPbkHandler->CreateContactObserverL( this );
+	}
+/**
+* Clears the connection to the contact engine
+*/
+void CNssContactHandlerImplementation::DisconnectFromPhonebook()
+	{
+	delete iPbkHandler;
+	iPbkHandler = NULL;
+	}
+#ifdef __SIND_EXTENSIONS
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::ReadExtensionsL
+// Reads the extension resource file
+// ---------------------------------------------------------
+//
+void CNssContactHandlerImplementation::ReadExtensionsL()
+{
+// using StringLoader should be used, but there is no
+// access to CCoeEnv
+// letters for drives in search order
+const TBuf<1> KResourceDrivers = _L("z");
+_LIT( KResourceFileName, "nssvascontacthandler.rsc" );
+// number of extension commands in the resource file
+const TInt KExtensionCommandCount = 8;
+// load resources
+RResourceFile resourceFile;
+RFs fs;
+CleanupClosePushL( fs );
+TBool found( EFalse );
+User::LeaveIfError( fs.Connect() );
+TFileName name;
+TInt i( 0 );
+// use the first drive
+name.Append( KResourceDrivers[i] );
+name.Append(':');
+name.Append( KDC_RESOURCE_FILES_DIR );
+name.Append( KResourceFileName );
+while ( !found && i < KResourceDrivers.Length() )
+{
+name[0] = KResourceDrivers[i++];
+BaflUtils::NearestLanguageFile( fs, name );
+if ( BaflUtils::FileExists(fs, name) )
+{
+// open resource
+resourceFile.OpenL( fs, name );
+CleanupClosePushL( resourceFile );
+resourceFile.ConfirmSignatureL();
+found = ETrue;
+}
+}
+if ( !found )
+{
+User::Leave( KErrNotFound );
+}
+for ( TInt extensionIndex( 0 ); extensionIndex < KExtensionCommandCount; extensionIndex++ )
+{
+TExtension extension;
+TResourceReader reader;
+TBool extentionSupported( ETrue );
+switch ( extensionIndex )
+{
+case 0:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_MOBILE ) );
+extension.iId = EPbkFieldIdPhoneNumberMobile;
+extension.iAction = EDial;
+extension.iCommand = EMobileCommand;
+break;
+case 1:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_MESSAGE ) );
+extension.iId = EPbkFieldIdPhoneNumberMobile;
+extension.iAction = ENewMessage;
+extension.iCommand = EMessageCommand;
+break;
+case 2:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_GENERAL ) );
+extension.iId = EPbkFieldIdPhoneNumberGeneral;
+extension.iAction = EDial;
+extension.iCommand = EGeneralCommand;
+break;
+case 3:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_WORK ) );
+extension.iId = EPbkFieldIdPhoneNumberWork;
+extension.iAction = EDial;
+extension.iCommand = EWorkCommand;
+break;
+case 4:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_HOME ) );
+extension.iId = EPbkFieldIdPhoneNumberHome;
+extension.iAction = EDial;
+extension.iCommand = EHomeCommand;
+break;
+case 5:
+if ( iVideoCallFeatureSupported )
+{
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_VIDEO ) );
+extension.iId = EPbkFieldIdPhoneNumberVideo;
+extension.iAction = EDial;
+extension.iCommand = EVideoCommand;
+}
+else
+{
+extentionSupported = EFalse;
+}
+break;
+case 6:
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_EMAIL ) );
+extension.iId =EPbkFieldIdEmailAddress ;
+extension.iAction = ENewEmail;
+extension.iCommand = EEmailCommand;
+break;
+case 7:
+if ( iVoIPFeatureSupported )
+{
+reader.SetBuffer( resourceFile.AllocReadLC( R_SIND_EXTENSION_VOIP ) );
+extension.iId = EPbkFieldIdVOIP;
+extension.iAction = EDial;
+extension.iCommand = EVoipCommand;
+}
+else
+{
+extentionSupported = EFalse;
+}
+break;
+default:
+User::Leave( KErrGeneral );  // !!! @todo: PANIC
+}
+if ( extentionSupported )
+{
+extension.iText = reader.ReadHBufCL();
+CleanupStack::PushL( extension.iText );
+User::LeaveIfError( iExtensionList.Append( extension ) );
+CleanupStack::Pop( extension.iText );
+CleanupStack::PopAndDestroy(); // AllocReadLC
+}
+}
+CleanupStack::PopAndDestroy( &resourceFile );
+CleanupStack::PopAndDestroy( &fs );
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::FindExtensionField
+// Finds the extension field based on priority lists
+// ---------------------------------------------------------
+//
+TInt CNssContactHandlerImplementation::FindExtensionField( TVasExtensionAction aAction,
+TPbkFieldId aDefaultFieldId )
+{
+TInt found = KErrNotFound;
+switch ( aDefaultFieldId )
+{
+case EPbkFieldIdPhoneNumberVideo:
+{
+// Use defaults for video extension
+found = ExtensionFieldFindLoop( KVideoExtensionFields, KVideoExtensionFieldsCount );
+break;
+}
+case EPbkFieldIdPhoneNumberMobile:
+{
+if ( aAction == ENewMessage )
+{
+// Use defaults for message extension
+found = ExtensionFieldFindLoop( KMessageExtensionFields, KMessageExtensionFieldsCount );
+}
+else
+{
+TRAP( found, iPbkHandler->FindFieldL( aDefaultFieldId ) );
+}
+break;
+}
+case EPbkFieldIdVOIP:
+{
+// Use defaults for VOIP extension
+found = ExtensionFieldFindLoop( KVOIPExtensionFields, KVOIPExtensionFieldsCount );
+break;
+}
+default:
+{
+TRAP( found, iPbkHandler->FindFieldL( aDefaultFieldId ) );
+break;
+}
+}
+return found;
+}
+// ---------------------------------------------------------
+// CNssContactHandlerImplementation::ExtensionFieldFindLoop
+// Finds the extension from the prioroty list arrays
+// ---------------------------------------------------------
+//
+TInt CNssContactHandlerImplementation::ExtensionFieldFindLoop( const TPbkFieldId* const aArray,
+TInt aCount )
+{
+TInt found = KErrNotFound;
+for ( TInt iCounter = 0; iCounter < aCount; iCounter++ )
+{
+TRAP( found, iPbkHandler->FindFieldL( aArray[iCounter] ) );
+if ( found == KErrNone )
+{
+break;
+}
+}
+return found;
+}
+#endif // __SIND_EXTENSIONS
+//  End of File

changeset 0	bf1d17376201
child 17	8ce15fced3a6