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

//

#include <e32base.h>

#include <e32property.h>

#include <ecom/ecom.h>

#include <lbs/lbslocerrors.h>

#include "lbsdevloggermacros.h"

#include <centralrepository.h>

#include <lbs/lbsadmin.h>

#include <lbs/gpssetclockbase.h>

#include "lbsadminimpl.h"

#if defined(LBSADMIN_UNIT_TEST)

#include "../test/te_lbsadmin/inc/te_lbsadminutils.h"

#endif

//

// NOTE: Please do not use switch statements when using the 'TLbsAdminSetting' type.

// 		 This is known to cause problems with how arm compliers handle 64 bit values.

//

//********************************************************************************************************

// Config Bus and its Policy

const TUid KConfigBusCategory = {0x1020E192}; //As the UID of this dll 

const TUid KLBSAdminRepositoryUid ={0x1028224B};

/** A bitmask containing all the settings */

const TLbsAdminSetting KAllSettings = 	

	KLbsSettingHomeSelfLocate |

	KLbsSettingRoamingSelfLocate |

	KLbsSettingQualityProfileSelfLocate |

	KLbsSettingHomeExternalLocate |

	KLbsSettingRoamingExternalLocate |

	KLbsSettingQualityProfileExternalLocate |

	KLbsSettingHomeEmergencyLocate |

	KLbsSettingRoamingEmergencyLocate |

	KLbsSettingHomeNetworkInducedLocate |

	KLbsSettingRoamingNetworkInducedLocate |

	KLbsSettingHomeTransmitLocate |

	KLbsSettingRoamingTransmitLocate |

	KLbsSettingQualityProfileTransmitLocate |

	KLbsSettingHomeGpsMode |

	KLbsSettingRoamingGpsMode |

	KLbsSettingHomeProtocolModule |

	KLbsSettingRoamingProtocolModule |

	KLbsSettingLbsSystemStartMode |

	KLbsSettingBehaviourMode |

	KLbsSettingPrivacyAppTimeout |

	KLbsSettingPrivacyTimeoutAction |

	KLbsSettingPrivacyHandler |

	KLbsSettingLogger |

	KLbsProtocolModuleLoading |

	KLbsSettingMaximumExternalLocateRequests |

	KLbsSettingPrivacyShutdownDelay |

	KLbsSettingPrivacyMaxNetworkSessions |

	KLbsSettingPrivacyConnectionTimeout |

	KLbsSettingClockAdjust |

	KLbsSettingAllowManualClockAdjust |

	KLbsSettingClockAdjustThreshold |

	KLbsSettingClockAdjustInterval |

	KLbsSettingSetClockModule;

// Used to initially create all the properties

const TLbsAdminSetting KKeysArray[]=

	{

	KLbsSettingHomeSelfLocate,

	KLbsSettingRoamingSelfLocate,

	KLbsSettingQualityProfileSelfLocate,

	KLbsSettingHomeExternalLocate,

	KLbsSettingRoamingExternalLocate,

	KLbsSettingQualityProfileExternalLocate,

	KLbsSettingHomeEmergencyLocate,

	KLbsSettingRoamingEmergencyLocate,

	KLbsSettingHomeTransmitLocate,

	KLbsSettingRoamingTransmitLocate,

	KLbsSettingQualityProfileTransmitLocate,

	KLbsSettingHomeGpsMode,

	KLbsSettingRoamingGpsMode,

	KLbsSettingHomeProtocolModule,

	KLbsSettingRoamingProtocolModule,

	KLbsSettingLbsSystemStartMode,

	KLbsSettingPrivacyTimeoutAction,

	KLbsSettingPrivacyHandler,		

	KLbsSettingBehaviourMode,

	KLbsSettingLogger,		

	KLbsSpecialFeatureMaximumRequestDelay,

	KLbsSpecialFeatureAllowTBFinalNetPos,

	KLbsSpecialFeatureWithholdDeliveryOfReferencePositions,

	KLbsProtocolModuleLoading,	

	KLbsSettingMaximumExternalLocateRequests,

	KLbsSettingPrivacyShutdownDelay,

	KLbsSettingPrivacyMaxNetworkSessions,	

	KLbsSettingPrivacyConnectionTimeout,				

	KLbsSpecialFeatureIgnoreAccuracy,

	KLbsSettingPrivacyAppTimeout,

	KLbsSpecialFeatureIntermediateFutileUpdate,

	KLbsSettingHomeNetworkInducedLocate,

	KLbsSettingRoamingNetworkInducedLocate,

	KLbsSettingSetClockModule,	

	KLbsSettingClockAdjustInterval,

	KLbsSettingClockAdjustThreshold,

	KLbsSettingClockAdjust,

	KLbsSettingAllowManualClockAdjust,

	};

const TInt KKeysArrayCount = sizeof(KKeysArray)/sizeof(TLbsAdminSetting);

// Uid of the Network Protocol ECom Plugin Interface

const TUid KNetworkProtocolInterfaceUid = {0x10281D4A};

//********************************************************************************************************

// Cleanup for a RPointerArray of subscribers

//********************************************************************************************************

void CleanupSubscribersArray(TAny* aSubscribersArrayPtr)

	{

	LBSLOG(ELogP1, "CleanupSubscribersArray()");

	RPointerArray<CAdminSettingSubscriber>* array = reinterpret_cast<RPointerArray<CAdminSettingSubscriber>*>(aSubscribersArrayPtr);

	TInt count = array->Count();

	for (TInt i = 0; i < count; i++)

		{

		delete (*array)[i];

		}

	array->Reset();

	}

//********************************************************************************************************

// CAdminSettingSubscriber

//********************************************************************************************************

/** Static constructor.

@released */

CAdminSettingSubscriber* CAdminSettingSubscriber::NewL(TUid aCategory, TLbsAdminSetting aSetting, MLbsAdminObserver& aObserver)

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::NewL()");

	CAdminSettingSubscriber* self = CAdminSettingSubscriber::NewLC(aCategory, aSetting, aObserver);

	CleanupStack::Pop(self);

	return self;

	}

/** Static constructor.

@released */

CAdminSettingSubscriber* CAdminSettingSubscriber::NewLC(TUid aCategory, TLbsAdminSetting aSetting, MLbsAdminObserver& aObserver)

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::NewLC()");

	CAdminSettingSubscriber* self = new(ELeave)CAdminSettingSubscriber(aCategory, aSetting, aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/** Second phase constructor 

@released */	

void CAdminSettingSubscriber::ConstructL()

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::ConstructL()");

	TInt err = iProperty.Attach(iCategory, LbsAdminUtils::BitPosToNumber(iSetting));

	User::LeaveIfError(err);

	iProperty.Subscribe(iStatus);

	SetActive();

	}	

/** Default constructor

@released */

CAdminSettingSubscriber::CAdminSettingSubscriber(TUid aCategory, TLbsAdminSetting aSetting, MLbsAdminObserver& aObserver)

: CActive(CActive::EPriorityUserInput),

iCategory(aCategory),

iSetting(aSetting),

iObserver(aObserver)

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::CAdminSettingSubscriber()");

	CActiveScheduler::Add(this);

	}

/** Default destructor

@released */

CAdminSettingSubscriber::~CAdminSettingSubscriber()

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::~CAdminSettingSubscriber()");

	Cancel();

	iProperty.Close();

	}

/*virtual*/ void CAdminSettingSubscriber::RunL()

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::RunL()");

	TInt err = iStatus.Int();

	iProperty.Subscribe(iStatus);

	LBSLOG(ELogP9, "<-A MLbsAdminObserver::OnSettingUpdateEvent() LbsAdmin\n");

	LBSLOG2(ELogP9, "  > TInt err  = %d\n", err);

	LBSLOG2(ELogP9, "  > TLbsAdminSetting iSetting  = 0x%016X\n", iSetting);

	iObserver.OnSettingUpdateEvent(err, iSetting);

	SetActive();	

	}

/*virtual*/ void CAdminSettingSubscriber::DoCancel()

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::DoCancel()");

	iProperty.Cancel();

	}

/*virtual*/ TInt CAdminSettingSubscriber::RunError(TInt aError)

	{

	LBSLOG(ELogP1, "CAdminSettingSubscriber::RunError()");

	return aError;

	}

//********************************************************************************************************

// Class CLbsAdminImplImpl - Public Methods

//********************************************************************************************************

/** Static constructor.

@return A pointer to the new CLbsAdminImpl object.

@capability WriteDeviceData if the configuration settings need to be created/initialised, none otherwise

@released */

CLbsAdminImpl* CLbsAdminImpl::NewL()

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::NewL()");

	CLbsAdminImpl* self = new(ELeave)CLbsAdminImpl(NULL);

	CleanupStack::PushL(self);

	self->ConstructL(KLbsSettingNone);

	CleanupStack::Pop(self);

	return self;

	}

/** Static constructor.

@return A pointer to the new CLbsAdminImpl object.

@capability WriteDeviceData if the configuration settings need to be created/initialised, none otherwise

@released */

CLbsAdminImpl* CLbsAdminImpl::NewL(MLbsAdminObserver& aObserver, const TLbsAdminSettingGroup& aSettingsMask)

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::NewL(MLbsAdminObserver, TLbsAdminSettingGroup)");

	CLbsAdminImpl* self = new(ELeave)CLbsAdminImpl(&aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(aSettingsMask);

	CleanupStack::Pop(self);

	return self;

	}

/** Second phase constructor 

@capability WriteDeviceData if the configuration settings need to be created/initialised, none otherwise

@released */	

void CLbsAdminImpl::ConstructL(const TLbsAdminSettingGroup& aSettingsMask)

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::ConstructL()");

	iCenRep = CRepository::NewL(KLBSAdminRepositoryUid);

	// Create the Properties with all the settings

	DefinePropertiesL();

	if (aSettingsMask != KLbsSettingNone)

		{

		SetNotificationMaskL(aSettingsMask);

		}

	}		

/** Default constructor 

@released */

CLbsAdminImpl::CLbsAdminImpl(MLbsAdminObserver* aObserver):

iObserver(aObserver),

iCenRep(NULL)

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::CLbsAdminImpl()");

	}

/** Default destructor */

CLbsAdminImpl::~CLbsAdminImpl()

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::~CLbsAdminImpl()");

	DeleteSubscribers();

	iSubscribers.Close();

	delete iCenRep;

	REComSession::FinalClose();

	}

// 

void CLbsAdminImpl::SetNotificationMaskL(const TLbsAdminSettingGroup& aSettingsMask)

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::SetNotificationMaskL()");

	if (aSettingsMask & ~KAllSettings)

		{

		User::Leave(KErrArgument);

		}

	__ASSERT_DEBUG(CActiveScheduler::Current(), User::Panic(KLbsAdminFault, EAdminActiveSchedulerNotInstalled));

	// Subscribers may exist already. Delete those not in aSettingMask and

	// prepare a new mask with only those settings in aSettingMask for which

	// a subscriber doesn't exist yet.

	TLbsAdminSettingGroup susbscriberCreationMask = aSettingsMask;

	DeleteSubscribersNotInMask(susbscriberCreationMask);	

	// Create the settings subscribers

	for (TUint i = 0; i < KKeysArrayCount; i++)

		{

		if ((KKeysArray[i]	& susbscriberCreationMask) != 0)

			{

			CAdminSettingSubscriber* newSubscriber = CAdminSettingSubscriber::NewLC(KConfigBusCategory, KKeysArray[i], *iObserver);

			iSubscribers.AppendL(newSubscriber);

			CleanupStack::Pop(newSubscriber);

			}

		}

	}

/** Cancels an outstanding setting event request

@see TLbsAdminSetting

@released */

void CLbsAdminImpl::ClearNotificationMask()

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::ClearNotificationMask()");

	DeleteSubscribers();

	}

TInt CLbsAdminImpl::ResetToDefault()

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::ResetToDefault()");

	TInt ret = KErrNone;

	ret = iCenRep->Reset();

	ASSERT(ret == KErrNone);

	if(ret==KErrNone)

		{

		// Notify the subscribers changing the value of all the properties.

		for (TInt i = 0; i < KKeysArrayCount; i++)

			{

			// Get the default value from CenRep and set the property with this value

			TInt value;

			ret = iCenRep->Get(LbsAdminUtils::BitPosToNumber(KKeysArray[i]),value);

			// If not found then is either an oldcenrep that hasn't got the new value in it or its corrupt!

			if (ret != KErrNone) 

				{

				// Look for new additions.

				switch (KKeysArray[i])

					{

					// Default logging is on.

					case KLbsSettingLogger:

						{

						value = CLbsAdmin::ELoggerOn;

						break;	

						}

					// Default is to load protocol modules at LBS start-up by roaming status.

					case KLbsProtocolModuleLoading:

						{

						value = TLbsAdminProtocolModuleLoadingInfo::EProtocolModuleLoadingByStatus;

						break;

						}

					// Default is to allow a single external locate request at a time

					case KLbsSettingMaximumExternalLocateRequests:

						{

						value = KLbsDefaultMaximumExternalLocateRequests;

						break;

						}

					// Default is a delay of 2 seconds

					case KLbsSettingPrivacyShutdownDelay:

						{

						value = KLbsDefaultPrivacyShutdownDelay;

						break;

						}

					// Default is to allow up to 4 concurrent network privacy sessions

					case KLbsSettingPrivacyMaxNetworkSessions:

						{

						value = KLbsDefaultPrivacyMaxNetworkSessions;

						break;

						}

					// Default is a timeout of 30 seconds

					case KLbsSettingPrivacyConnectionTimeout:

						{

						value = KLbsDefaultPrivacyConnectionTimeout;

						break;

						}

					// Default is feature off.

					case KLbsSpecialFeatureMaximumRequestDelay:

						{

						value = 0;	// 0 denotes off.	

						break;	

						}

						// Default is feature off.

					case KLbsSpecialFeatureAllowTBFinalNetPos:

						{

						value = CLbsAdmin::ESpecialFeatureOff;						

						break;

						}

  					// Default is feature off.

  					case KLbsSettingBehaviourMode:

 						value = CLbsAdmin::ELbsBehaviourCustom1;

 						break;

					// Default is feature off.

					case KLbsSpecialFeatureWithholdDeliveryOfReferencePositions:

						{

						value = CLbsAdmin::ESpecialFeatureOff;						

						break;

						}

					// Default is feature off - the value is original symbian behaviour - ignore accuracy off.

					case KLbsSpecialFeatureIgnoreAccuracy:

						{

						value = CLbsAdmin::ESpecialFeatureOff;

						break;

						}

					case KLbsSettingPrivacyAppTimeout:

						{

						// for binary data compatibility set to a default value, 20s

						value = 20*1000;

						break;

						}

					// default value is original symbian behaviour - don't check for intermediate futile updates

					case KLbsSpecialFeatureIntermediateFutileUpdate:

						{

						value = CLbsAdmin::ESpecialFeatureOff;

						break;

						}

					// Default is Off, reject network induced privacy requests.

					case KLbsSettingHomeNetworkInducedLocate:

					case KLbsSettingRoamingNetworkInducedLocate:

						{

						value = CLbsAdmin::EExternalLocateOff;

						break;

						}

					// Setting really not found.

					default:

						{

						return ret;

						}

					}

				}

			// Set property here.

			ret = RProperty::Set(KConfigBusCategory, LbsAdminUtils::BitPosToNumber(KKeysArray[i]), value);

			if (ret != KErrNone) break;

			}

		}

	LBSLOG2(ELogP3, "NEW ACTION: Lbs Admin settings reset. errr: %d", ret);	

	return ret;

	}

/** Updates a setting in a relevant property and in the corresponding

Central Repository setting.

This method should be used by one of overloaded DoSet()s after

validating the attributes.

@param aSetting The setting to be changed.

@param aValue   The new value of the setting.

@return KErrNone if property has been set,  one of the system wide error codes otherwise.

@capability WriteDeviceData

@see TLbsAdminSetting

@released */

TInt CLbsAdminImpl::SetSettingValidated(TLbsAdminSetting aSetting, const TInt& aValue)

	{

	LBSLOG(ELogP1, "CLbsAdminImpl::SetSettingValidated()");

	// Validate value for particular setting

	TInt err = LbsAdminUtils::ValidateValue(aSetting, aValue);

	if (err != KErrNone)

		{

		return err;

		}

	// For settings that are changing a plugin Uid value, verify that

	// the plugin exists first

	// "Switch/Case" does not work with TInt64 so we have to use "if" instead

	if ((aSetting == KLbsSettingHomeProtocolModule) ||

		(aSetting == KLbsSettingRoamingProtocolModule) ||

		(aSetting == KLbsSettingSetClockModule))

		{

        #if defined(LBSADMIN_UNIT_TEST)

		// For unit testing we need to be able to set a Uid value, 

		// so use this test function instead of the real one to do it.

		TInt err = te_LbsAdminUtils::ConfirmSettingPluginExists(aSetting, aValue);

        #else

		TInt err = LbsAdminUtils::ConfirmSettingPluginExists(aSetting, aValue);

        #endif // LBSADMIN_UNIT_TEST

		if (err != KErrNone)

			{

			return err;

			}

		}

	TInt ret = KErrNone;

	ret = RProperty::Set(KConfigBusCategory, LbsAdminUtils::BitPosToNumber(aSetting), aValue);

	if(ret == KErrNone)

		{

		// A failure to write to the Central Repository is ignored as iCenRep is only used for

		// persitance (admin setting values are read from properties in CLbsAdminImpl::GetValidated)

		ret = iCenRep->Set(LbsAdminUtils::BitPosToNumber(aSetting), aValue);

		}

	if(ret == KErrNone)

		{

		ret = SyncCenrep(aSetting);

		}