/*

* 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 ) )

        	{