// Copyright (c) 2002-2009 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:

// Contains implementations for the Active Object based notification

// classes.

// 

//

/**

 @file

 @internalComponent

*/

#include <connect/sbdefs.h>

#include <etelmm.h>

#include <etelsat.h>

#include <satcs.h>

#include "common.h"

#include "Phonebook.h"

#include "PhonebookManager.h"

#include "SyncContactICCEntry.h"

#include "phbksynclog.h"

#include "phbksyncsvr.h"

#include "SyncEngineSession.h"

#include "SyncEngineServer.h"

#include "phbksyncsess.h"

#include "ActiveNotifications.h"

using namespace conn;

//

// Some timing constants...

//

const TInt  KActiveNotificationInitialDelayInSeconds = 5;

const TInt  KActiveNotificationMaxDelayInSeconds     = 2560;

const TInt  KOneSecondInMS                           = 1000000;

//

// Definition of the locks used by CNotifyLockInfoChange...

//

const TInt  KLockInfoNumberOfLocks = 5;

const RMobilePhone::TMobilePhoneLock  KLockInfoList[KLockInfoNumberOfLocks] =

											{RMobilePhone::ELockICC,

											 RMobilePhone::ELockPin2,

											 RMobilePhone::ELockHiddenKey,

											 RMobilePhone::ELockUSimApp,

											 RMobilePhone::ELockUniversalPin};

/**

 *  Standard constructor.

 *

 *  @param aServer  Pointer to the front-end server.

 */

CActiveNotificationBase::CActiveNotificationBase(CPhoneBookServer& aServer)

  : CActive(EPriorityNormal),

	iIsNotificationInProgress(EFalse),

	iLastDelay(0),

	iServer(aServer),

	iTimer()

	{

	CActiveScheduler::Add(this);

	} // CActiveNotificationBase::CActiveNotificationBase

/**

 *  Standard destructor. Derived classes will need to implement a destructor

 *  too, so that the active notification can be cancelled.

 */

CActiveNotificationBase::~CActiveNotificationBase()

	{

	LOGACTIVE1(_L8("CActiveNotificationBase::~CActiveNotificationBase()"));

	iTimer.Close();

	} // CActiveNotificationBase::~CActiveNotificationBase

/**

 *  This function starts the Active Notification object. Until it is cancelled

 *  the CompleteNotification() and PostNotification() functions will be called

 *  each time the notification triggers.

 *

 *  @return Returns KErrNone if the notification starts, a system error

 *          code otherwise.

 */

TInt CActiveNotificationBase::Start()

	{

	LOGACTIVE1(_L8("CActiveNotificationBase::Start()"));

	//

	// Check if this Active Notifier is running...

	//

	if (IsActive())

		{

		return KErrInUse;

		}

	//

	// Create the RTimer...

	//

	TInt  result;

	result = iTimer.CreateLocal();

	if (result != KErrNone)

		{

		return result;

		}

	//

	// Start the notifications...

	//

	PostNotification();

	iIsNotificationInProgress = ETrue;

	iLastDelay = 0;

	return KErrNone;

	} // CActiveNotificationBase::Start

/**

 *  Virtual function, overridden by the derived class, which performs the

 *  task of issuing the notification.

 */

void CActiveNotificationBase::PostNotification()

	{

	LOGACTIVE1(_L8("CActiveNotificationBase::PostNotification()"));

	//

	// To be implemented by the derived class...

	//

	} // CActiveNotificationBase::PostNotification

/**

 *  Virtual function, overridden by the derived class, which performs the

 *  task of completing the notification. Normally this means a function call

 *  is made on the server object to let it know the event has occured.

 *

 *  @param aRetVal  Result of the notification.

 */

void CActiveNotificationBase::CompleteNotification(TInt aRetVal)

	{

	LOGACTIVE2(_L8("CActiveNotificationBase::CompleteNotification(%d)"),

			   aRetVal);

	//

	// To be implemented by the derived class...

	//

	(void) aRetVal;

	} // CActiveNotificationBase::CompleteNotification

/**

 *  Virtual function, overridden by the derived class, which performs the

 *  task of cancelling the notification.

 */

void CActiveNotificationBase::CancelNotification()

	{

	LOGACTIVE1(_L8("CActiveNotificationBase::CancelNotification()"));

	//

	// To be implemented by the derived class...

	//

	} // CActiveNotificationBase::CancelNotification

/**

 *  Standard Active Object RunL() method to process requests. This function

 *  is called when either the notification request completes or when the timer

 *  delay completes.

 *

 *  The function decides whether to repost the notification, delay and then

 *  repost or to just stop the notification altogether.

 */

void CActiveNotificationBase::RunL()

	{

	LOGACTIVE2(_L8("CActiveNotificationBase::RunL(): iStatus=%d"), iStatus.Int());

	//

	// Handle the result of the last request or timer request...

	//

	if (iIsNotificationInProgress)

		{

		TInt  retVal(iStatus.Int()); // Stored as iStatus may change!

		iIsNotificationInProgress = EFalse;

		CompleteNotification(retVal);

		//

		// Now work out what to do next. If this was successful then repost,

		// otherwise stop the notification or delay then repost.

		//

		if (retVal == KErrNone)

			{

			//

			// The previous notification was successful so repost...

			//

			LOGACTIVE1(_L8("CActiveNotificationBase::RunL(): Reposting..."));

			PostNotification();

			iIsNotificationInProgress = ETrue;

			iLastDelay = 0;

			}

		else if (retVal == KErrNotFound  ||  retVal == KErrCancel  ||

				 retVal == KErrNotSupported)

			{

			//

			// The previous notification returned an error code that indicates

			// it is not worth reposting.

			//

			LOGACTIVE1(_L8("CActiveNotificationBase::RunL(): Stopping..."));

			}

		else

			{

			//

			// The previous notification returned an error code that suggests

			// we should retry in a while. Delay some seconds.

			//

			// If this is the first delay since a successful notification then

			// delay the initial ammount, otherwise double the delay used last

			// time. If we have exceed the maximum delay then stop.

			//

			LOGACTIVE1(_L8("CActiveNotificationBase::RunL(): Delaying..."));

			if (iLastDelay == 0)

				{

				iLastDelay = KActiveNotificationInitialDelayInSeconds;

				}

			else

				{

				iLastDelay = iLastDelay * 2;

				}

			if (iLastDelay < KActiveNotificationMaxDelayInSeconds)

				{

				LOGACTIVE2(_L8("CActiveNotificationBase::RunL(): Delaying %d seconds"),

						   iLastDelay);

				iTimer.After(iStatus, iLastDelay * KOneSecondInMS);

				SetActive();

				}

			else

				{

				LOGACTIVE1(_L8("CActiveNotificationBase::RunL(): Out of time..."));

				}

			}

		}

	else

		{

		//

		// The timer must have expired (either on time or because of some

		// other event such as timezone change).

		//

		// Retry the notification...

		//

		LOGACTIVE1(_L8("CActiveNotificationBase::RunL(): Reposting again..."));

		PostNotification();

		iIsNotificationInProgress = ETrue;

		}

	} // CActiveNotificationBase::RunL

/**

 *  Standard Active Object RunErrorL() function. This is called if the RunL()

 *  leaves. Hopefully this should not happen!

 *

 *  @param aError  Leave code from the RunL().

 *

 *  @return KErrNone (although it panics first).

 */

TInt CActiveNotificationBase::RunError(TInt aError)

	{

#ifdef _DEBUG

	LOGACTIVE2(_L8("CActiveNotificationBase::RunError(%d)"), aError);

#else

	(void) aError;

#endif

	PhBkSyncPanic(EPhBkSyncPanicUnexpectedLeave);

	return KErrNone;	

	} // CActiveNotificationBase::RunError

/**

 *  Standard Active Object DoCancel method. This is called when Cancel()

 *  is called on the object and a request is active.

 */

void CActiveNotificationBase::DoCancel()

	{

	LOGACTIVE1(_L8("CActiveNotificationBase::DoCancel()"));

	if (iIsNotificationInProgress)

		{

		CancelNotification();

		}

	else

		{

		iTimer.Cancel();

		}

	} // CActiveNotificationBase::DoCancel

/**

 *  Static factory method used to create a CGetPhoneStoreInfo object.

 *

 *  @param aServer            Reference to the front-end server object.

 *  @param aPhonebookManager  Reference to the Phonebook Manager object.

 *  @param aPhone             Handle to the phone object.

 *

 *  @return  Pointer to the created CNotifySecurityEvent object, or NULL.

 */

CGetPhoneStoreInfo* CGetPhoneStoreInfo::NewL(CPhoneBookServer& aServer,

											 CPhoneBookManager& aPhonebookManager,

											 RMobilePhone& aPhone)

	{

	CGetPhoneStoreInfo* self = new(ELeave) CGetPhoneStoreInfo(aServer,

															  aPhonebookManager,

															  aPhone);

	return self;

	} // CGetPhoneStoreInfo::NewL

/**

 *  Standard constructor.

 *

 *  @param aServer            Reference to the front-end server object.

 *  @param aPhonebookManager  Reference to the Phonebook Manager object.

 *  @param aPhone             Handle to the phone object.

 */

CGetPhoneStoreInfo::CGetPhoneStoreInfo(CPhoneBookServer& aServer,

									   CPhoneBookManager& aPhonebookManager,

									   RMobilePhone& aPhone)

  : CActiveNotificationBase(aServer),

    iPhonebookManager(aPhonebookManager),

    iPhone(aPhone),

    iPhonebookUid(KUidIccPhonebookNotSpecified),

    iPhonebookCount(-1),

    iStoreInfoPckgV1(iStoreInfoV1),

    iStoreInfoPckgV2(iStoreInfoV2),

    iStoreInfoPckgV5(iStoreInfoV5)

	{

	SelectNextPhonebook();

	} // CGetPhoneStoreInfo::CGetPhoneStoreInfo

/**

 *  Standard destructor.

 */

CGetPhoneStoreInfo::~CGetPhoneStoreInfo()

	{

	LOGACTIVE1(_L8("CGetPhoneStoreInfo::~CGetPhoneStoreInfo()"));

	Cancel();

	iPhonebooksToRefresh.Close();

	} // CGetPhoneStoreInfo::~CGetPhoneStoreInfo

/**

 *  Virtual method called by the CActiveNotificationBase class to post

 *  the GetPhoneStoreInfo request.

 */

void CGetPhoneStoreInfo::PostNotification()

	{

	LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification()"));

	//

	// Check if a phonebook remains to have it's info retrieved...

	//

	if (iPhonebookUid != KUidIccPhonebookNotSpecified)

		{

		//

		// Work out the store name...

		//

		if (iPhonebookUid == KUidIccGlobalAdnPhonebook)

			{

			LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification(): Getting ADN."));

			iStore.iStoreName = KETelIccAdnPhoneBook;

			iStore.iMode = KEtelGsmPhoneBookType;

			}

		else if (iPhonebookUid == KUidIccGlobalSdnPhonebook)

			{

			LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification(): Getting SDN."));

			iStore.iStoreName = KETelIccSdnPhoneBook;

			iStore.iMode = KEtelGsmPhoneBookType;

			}

		else if (iPhonebookUid == KUidIccGlobalLndPhonebook)

			{

			LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification(): Getting LND."));

			iStore.iStoreName = KETelIccLndPhoneBook;

			iStore.iMode = KEtelGsmPhoneBookType;

			}

		else if (iPhonebookUid == KUidUsimAppAdnPhonebook)

			{

			LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification(): Getting USIM ADN."));

			iStore.iStoreName = KETelIccAdnPhoneBook;

			iStore.iMode = KEtelUSimPhoneBookType;

			}

		else if (iPhonebookUid == KUidIccGlobalFdnPhonebook)

			{

			LOGACTIVE1(_L8("CGetPhoneStoreInfo::PostNotification(): Getting FDN."));

			iStore.iStoreName = KETelIccFdnPhoneBook;

			iStore.iMode = KEtelGsmPhoneBookType;

			}

		else

			{

			PhBkSyncPanic(EPhBkSyncPanicTooManyPhonebooks);

			}

		//

		// Request the phone store info...

		//

		if (Server().IsV5Tsy())

			{

			iPhone.GetPhoneStoreInfo(iStatus, iStoreInfoPckgV5,

									 iStore.iStoreName, iStore.iMode);

			}

		else if (Server().IsV2Tsy())

			{

			iPhone.GetPhoneStoreInfo(iStatus, iStoreInfoPckgV2,

									 iStore.iStoreName, iStore.iMode);

			}

		else

			{

			iPhone.GetPhoneStoreInfo(iStatus, iStoreInfoPckgV1,

									 iStore.iStoreName);

			}

		SetActive();

		}

	} // CGetPhoneStoreInfo::PostNotification

/**

 *  Virtual method called by the CActiveNotificationBase class to complete

 *  the GetPhoneStoreInfo request.

 *

 *  @param aRetVal  Result of the notification request.

 */

void CGetPhoneStoreInfo::CompleteNotification(TInt aRetVal)

	{

	LOGACTIVE2(_L8("CGetPhoneStoreInfo::CompleteNotification(%d)"), aRetVal);

	//

	// Was this successful???

	//

	if (aRetVal == KErrNone)

		{

		//

		// PhBkSync cannot deal with phonebooks with no identity as it

		// causes later problems with the INI file parsing. So we take

		// care of it here before was pass this information to the server.

		//

		if (Server().IsV5Tsy())

			{

			if (iStoreInfoV5.iIdentity.Length() == 0)

				{

				iStoreInfoV5.iIdentity.Copy(KPhonebookIdUnknown);

				}

			Server().CompleteGetPhoneStoreInfo(aRetVal, iStoreInfoV5,

											   iPhonebookUid);	

			}

		else if (Server().IsV2Tsy())

			{

			if (iStoreInfoV2.iIdentity.Length() == 0)

				{

				iStoreInfoV2.iIdentity.Copy(KPhonebookIdUnknown);

				}

			Server().CompleteGetPhoneStoreInfo(aRetVal, 

											   static_cast<RMobilePhoneBookStore::TMobilePhoneBookInfoV5&>(iStoreInfoV2),

											   iPhonebookUid);

			}

		else

			{

			if (iStoreInfoV1.iIdentity.Length() == 0)

				{

				iStoreInfoV1.iIdentity.Copy(KPhonebookIdUnknown);

				}

			Server().CompleteGetPhoneStoreInfo(aRetVal,

											   static_cast<RMobilePhoneBookStore::TMobilePhoneBookInfoV5&>(iStoreInfoV1),

											   iPhonebookUid);

			}

		if (iAutoSyncRequired)

			{

			Server().QueueAutoSyncRequest(iPhonebookUid);

			}

		SelectNextPhonebook();

		}

	else if (aRetVal == KErrNotFound  ||  aRetVal == KErrCancel  ||

		     aRetVal == KErrNotSupported)

		{

		Server().CompleteGetPhoneStoreInfo(aRetVal, iStoreInfoV5,

										   iPhonebookUid);

		//

		// This will not be retried, so move onto the next phonebook...

		//

		SelectNextPhonebook();

		PostNotification();

		}

	else

		{

		//

		// This failure will be retried by the CActiveNotificationBase...

		//

		}

	} // CGetPhoneStoreInfo::CompleteNotification