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

// Privacy handler for Location Update requests

// 

//

#include <e32base.h>

#include <lbs/lbsadmin.h>

#include "lbsdevloggermacros.h"

#include <lbs/lbslocclasstypes.h>

#include "lbsprivacynotifier.h"

#include "privacyhandlerobserver.h"

#include "privacyhandler.h"

#include "lbsprivacycontrollerdata.h"

#include "LbsInternalInterface.h"

#include "lbsqualityprofile.h"

#ifdef SYMBIAN_LOCATION_PRIVACY_V2

	#include "privacyadvancednotifierhandler.h"

#endif

const TInt KErrLbsNotifierUnknown = KErrUnknown; // for now....

//===================================================================================================

CPrivacyHandler* CPrivacyHandler::CreateL(MPrivacyHandlerObserver* aObserver,

                                          CLbsAdmin& aLbsAdmin,

                                          RLbsNetworkRegistrationStatus& aNetRegStatus)

	{

	CPrivacyHandler* implementation = 0;

	// Find out whether we're referring notification/verification to a notifier 

	// or a controller.

	CLbsAdmin::TPrivacyHandler privacyHandler;

	aLbsAdmin.Get(KLbsSettingPrivacyHandler, privacyHandler);

	switch(privacyHandler)

		{

		case CLbsAdmin::EPrivacyHandleByNotifier:

			{

			implementation = CPrivacyNotifierHandler::NewL(aLbsAdmin,

														   aNetRegStatus);

			break;

			}

		case CLbsAdmin::EPrivacyHandleByController:

			{

			implementation = CPrivacyControllerHandler::NewL(aLbsAdmin,

															 aNetRegStatus);

			break;

			}

#ifdef SYMBIAN_LOCATION_PRIVACY_V2

		case CLbsAdmin::EPrivacyHandleByAdvancedNotifier:

			{

			implementation = CPrivacyAdvancedNotifierHandler::NewL(aLbsAdmin,

																   aNetRegStatus);

			break;

			}

#endif

		default:

			{

			User::Leave(KErrLbsNotifierUnknown);

			break;

			}

		}

	implementation->RegisterObserver(aObserver);    

	return(implementation);

	}

CPrivacyHandler::CPrivacyHandler(CLbsAdmin& aLbsAdmin,

								 RLbsNetworkRegistrationStatus& aNetRegStatus)

: CActive(EPriorityStandard),

	iLbsAdmin(aLbsAdmin),

	iNetRegStatus(aNetRegStatus)

	{		

	}

/* Get the current value for the admin setting for external locate.

This functions checks the network registration (i.e. 'roaming') status

and reads either the 'home' or 'network' admin setting as appropriate. 

*/

void CPrivacyHandler::GetExternalLocateAdminSetting(const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, CLbsAdmin::TExternalLocateService& aExternalLocateService)

	{

	CLbsAdmin::TExternalLocateService								serviceStatus(CLbsAdmin::EExternalLocateOff);

	RLbsNetworkRegistrationStatus::TLbsNetworkRegistrationStatus	netRegStatus(RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown);	

	// Rread the network regisration to determine if currently roaming.

	TInt err = iNetRegStatus.GetNetworkRegistrationStatus(netRegStatus);

	if (err == KErrNone)

		{

		// Determine service status based on the normal MT-LR admin settings.

		if (aSessionType == TLbsNetworkEnumInt::EServiceMobileTerminated)

			{

			switch (netRegStatus)

				{

				case RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork:

					{

					err = iLbsAdmin.Get(KLbsSettingHomeExternalLocate, serviceStatus);

					break;

					}

				case RLbsNetworkRegistrationStatus::ERegisteredRoamingNetwork:

				case RLbsNetworkRegistrationStatus::ENotRegistered:

					{

					err = iLbsAdmin.Get(KLbsSettingRoamingExternalLocate, serviceStatus);

					break;

					}		

				case RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown:

				default:

					{

					LBSLOG_WARN2(ELogP4, "Unrecognised TLbsNetworkRegistrationStatus (%d), defaulting to EExternalLocateOff", netRegStatus);

					break;

					}

				}

			}

		// Determine service status based on the network induced MT-LR admin settings.

		else if (aSessionType == TLbsNetworkEnumInt::EServiceNetworkInduced)

			{

			switch (netRegStatus)

				{

				case RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork:

					{

					err = iLbsAdmin.Get(KLbsSettingHomeNetworkInducedLocate, serviceStatus);

					break;

					}

				case RLbsNetworkRegistrationStatus::ERegisteredRoamingNetwork:

				case RLbsNetworkRegistrationStatus::ENotRegistered:

					{

					err = iLbsAdmin.Get(KLbsSettingRoamingNetworkInducedLocate, serviceStatus);

					break;

					}		

				case RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown:

				default:

					{

					LBSLOG_WARN2(ELogP4, "Unrecognised TLbsNetworkRegistrationStatus (%d), defaulting to EExternalLocateOff", netRegStatus);

					break;

					}

				}

			}

		else

			{

			LBSLOG_WARN2(ELogP4, "Unsupported TLbsNetworkEnumInt::TLbsNetProtocolServiceInt (%d), defaulting to EExternalLocateOff", aSessionType);

			}

		}

	else

		{

		LBSLOG_WARN2(ELogP4, "Failed to get TExternalLocateService, couldn't read roaming status (err %d), defaulting to EExternalLocateOff", err);		

		}

	// Error during admin get. 

	if (err)

		{

		serviceStatus = CLbsAdmin::EExternalLocateOff;

		}

	aExternalLocateService = serviceStatus;

	}

/** Get the default privacy response based on the admin setting.

 */

void CPrivacyHandler::GetPrivacyTimeoutAction(

		TLbsNetworkEnumInt::TLbsPrivacyResponseInt& aResponse, 

		const TLbsNetPosRequestPrivacyInt& aRequestPrivacy)

	{

	CLbsAdmin::TPrivacyTimeoutAction privacyTimeoutAction;

	iLbsAdmin.Get(KLbsSettingPrivacyTimeoutAction, privacyTimeoutAction);

	switch(privacyTimeoutAction)

		{

		case CLbsAdmin::EPrivacyTimeoutReject:

			{

			aResponse = TLbsNetworkEnumInt::EPrivacyResponseRejected;

			break;

			}

		case CLbsAdmin::EPrivacyTimeoutNetworkDefined:

			{

			//Use the network defined action to decide whether to reject/accept

			switch(aRequestPrivacy.RequestAction())

				{

				case TLbsNetPosRequestPrivacyInt::ERequestActionAllow:

					{

					aResponse = TLbsNetworkEnumInt::EPrivacyResponseAccepted;

					break;

					}

				case TLbsNetPosRequestPrivacyInt::ERequestActionReject:

				case TLbsNetPosRequestPrivacyInt::ERequestActionNotUsed:

					{

					aResponse = TLbsNetworkEnumInt::EPrivacyResponseRejected;

					break;

					}

				}

			break;

			}

		default:

			{

			aResponse = TLbsNetworkEnumInt::EPrivacyResponseRejected;

			break;

			}

		}	

	}

//

// CPrivacyRequest

//

CPrivacyRequest::CPrivacyRequest()

	{

	}

CPrivacyRequest::~CPrivacyRequest()

	{

	}

CPrivacyRequest* CPrivacyRequest::NewL()

	{

	CPrivacyRequest* self = new (ELeave) CPrivacyRequest;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CPrivacyRequest::ConstructL()

	{

	}

CPrivacyRequest::TPrivReqState CPrivacyRequest::State() const

	{

	return iState;

	}

void CPrivacyRequest::SetState(CPrivacyRequest::TPrivReqState aState)

	{

	iState = aState;

	}

const TLbsNetSessionIdInt& CPrivacyRequest::SessionId() const

	{

	return iSessionId;

	}

void CPrivacyRequest::SetSessionId(const TLbsNetSessionIdInt& aSessionId)

	{

	iSessionId = aSessionId;

	}

const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt& CPrivacyRequest::SessionType() const

	{

	return iSessionType;

	}

void CPrivacyRequest::SetSessionType(const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt& aSessionType)

	{

	iSessionType = aSessionType;

	}

const TLbsExternalRequestInfo& CPrivacyRequest::RequestInfo() const

	{

	return iRequestInfo;

	}

void CPrivacyRequest::SetRequestInfo(const TLbsExternalRequestInfo& aRequestInfo)

	{

	Mem::Copy(&iRequestInfo, &aRequestInfo, aRequestInfo.ClassSize());

	}

const TLbsNetPosRequestPrivacyInt& CPrivacyRequest::RequestPrivacy() const

	{

	return iRequestPrivacy;

	}

void CPrivacyRequest::SetRequestPrivacy(const TLbsNetPosRequestPrivacyInt& aRequestPrivacy)

	{

	iRequestPrivacy = aRequestPrivacy;

	}

TBool CPrivacyRequest::IsEmergency() const

	{

	return iIsEmergency;

	}

void CPrivacyRequest::SetIsEmergency(TBool aIsEmergency)

	{

	iIsEmergency = aIsEmergency;

	}

TTime CPrivacyRequest::StartTime() const

	{

	return iStartTime;

	}

void CPrivacyRequest::SetStartTime()

	{

	iStartTime.UniversalTime();

	}

/** Comparison function for RPointerArray<CPrivacyRequest>::Find()

 */

TBool CPrivacyRequest::IsSessionIdEqual(

		const TLbsNetSessionIdInt* aSessionId,

		const CPrivacyRequest& aItem)

	{

	return (*aSessionId == aItem.SessionId());

	}

//

// CPrivacyNotifierHandler

//

CPrivacyNotifierHandler::CPrivacyNotifierHandler(CLbsAdmin& aLbsAdmin,

												 RLbsNetworkRegistrationStatus& aNetRegStatus) : 

	CPrivacyHandler(aLbsAdmin, aNetRegStatus)

    {

	iPrivacyResponseOutstanding = EFalse;

    }

CPrivacyNotifierHandler* CPrivacyNotifierHandler::NewL(CLbsAdmin& aLbsAdmin,

													   RLbsNetworkRegistrationStatus& aNetRegStatus)

    {

	CPrivacyNotifierHandler* self = new (ELeave)CPrivacyNotifierHandler(aLbsAdmin,

																		aNetRegStatus);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

    }

/**

*/

void CPrivacyNotifierHandler::ConstructL()

	{

	CActiveScheduler::Add(this);

	iPrivacyResponseTimer = CLbsCallbackTimer::NewL(*this);

	}

/**

 * Called when the response timer expires.

 * An accept or reject of the original query is reported to the NRH 

 * depending on the request action parameter received with the original request.

 * @param aTimerId always 1 (we only use one timer in this subcomponent)

 */

void CPrivacyNotifierHandler::OnTimerEventL(TInt aTimerId)

	{

	iNotifier->Cancel();

	switch (aTimerId)

		{

		case 1:

			{

			// The privacy notifier has timed out without a response being

			// received. Generate a response as required depending upon

			// the LbsAdmin setting: TPrivacyTimeoutAction

			CPrivacyRequest* request = iRequestBuffer[0];

			TLbsNetworkEnumInt::TLbsPrivacyResponseInt response;

			GetPrivacyTimeoutAction(response, request->RequestPrivacy());

			iObserver->OnRespondNetworkLocationRequest(

					request->SessionId(), response, KErrNone);

			// Delete the current request and start the next one in the buffer

			iRequestBuffer.Remove(0);

			delete request; 

          	SendNextPrivacyRequest();

			break;

			}

		default:

			// do nothing

			break;	

		}

	}

TInt CPrivacyNotifierHandler::OnTimerError(TInt /*aTimerId*/, 

											TInt aError)

	{

	// Not used - OnTimerEventL doesn't generate any error.

	return(aError);

	}

void CPrivacyNotifierHandler::ProcessNetworkLocationRequest(

		TLbsNetSessionIdInt aSessionId,

		const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 		

        const TLbsExternalRequestInfo&  aRequestInfo, 

        const TLbsNetPosRequestPrivacyInt& aNetPosRequestPrivacy,

        TBool aIsEmergency)

	{

	BufferPrivacyRequest(aSessionId, aSessionType, aRequestInfo, aNetPosRequestPrivacy, aIsEmergency);

	if (!IsPrivacyRequestActive())

		{

		SendNextPrivacyRequest();

		}

	}

void CPrivacyNotifierHandler::ProcessNetworkPositionUpdate(TLbsNetSessionIdInt /*aSessionId*/, 

                                           const TPositionInfo& /*aPosInfo*/)

    {

    }

void CPrivacyNotifierHandler::ProcessRequestComplete(TLbsNetSessionIdInt aSessionId, TInt /*aReason*/)

    {

    // If the current request is still in the buffer here, 

    // it is because it is still waiting for a reponse.

    // So, we need to cancel the notifier and clean up.

    if (iRequestBuffer.Count() > 0

    	&& aSessionId == iRequestBuffer[0]->SessionId())

    	{

    	CPrivacyRequest* request = iRequestBuffer[0];

    	// If the completed request is the currently active one,

    	// may need to cancel the notifer and timer as well.

		if (iNotifier)

			{

			iNotifier->Cancel();

			}

		iPrivacyResponseTimer->Cancel();

		// Delete the completed request

		iRequestBuffer.Remove(0);

		delete request; 

    	}

    }

void CPrivacyNotifierHandler::RegisterObserver(MPrivacyHandlerObserver* aObserver)

    {

    iObserver = aObserver;	

    }

CPrivacyNotifierHandler::~CPrivacyNotifierHandler()

    {	

    if(iNotifier)

    	{

    	iNotifier->Cancel();

    	}

    delete iNotifier;

    iRequestBuffer.ResetAndDestroy();

	iPrivacyResponseTimer->Cancel();

	delete iPrivacyResponseTimer;

    Cancel();

    }

// From MLbsPrivacyNotifierObserver

void CPrivacyNotifierHandler::OnNotificationDialogResponse(TInt aErr , 

	                         const TLbsPrivacyNotifierResponse& aResponse)

	{

	iPrivacyResponseTimer->Cancel();

	iPrivacyResponseOutstanding = EFalse;

	CPrivacyRequest* request = iRequestBuffer[0];

	if(aErr == KErrNone)

		{

		switch(aResponse)

			{

			case EResponseAccepted:

				{

				iObserver->OnRespondNetworkLocationRequest(request->SessionId(), 

						TLbsNetworkEnumInt::EPrivacyResponseAccepted, KErrNone);				

				break;

				}

			case EResponseTimedOut:

				{

				iNotifier->Cancel();

				TLbsNetworkEnumInt::TLbsPrivacyResponseInt response;

				GetPrivacyTimeoutAction(response, request->RequestPrivacy());

				iObserver->OnRespondNetworkLocationRequest(

									request->SessionId(), response, KErrNone);

				break; // case EResponseTimedOut

				}

			default:				

			case EResponseRejected:

				{

				iObserver->OnRespondNetworkLocationRequest(request->SessionId(), 

						TLbsNetworkEnumInt::EPrivacyResponseRejected, KErrNone);				

				break;

				}

			}

		}

	else			

	// Treat any error as an 'unknown' response

		{

		iObserver->OnRespondNetworkLocationRequest(request->SessionId(), 

					TLbsNetworkEnumInt::EPrivacyResponseUnknown, KErrArgument);

		}

	// Delete the current request and start the next one in the buffer

	iRequestBuffer.Remove(0);

	delete request; 

   	SendNextPrivacyRequest();

	}

/* Return ETrue if we are currently waiting on the RNotifier dialog.

Uses the response timer, because this should only be running

when we are waiting for the RNotifier.

*/

TBool CPrivacyNotifierHandler::IsPrivacyRequestActive()

	{

	return (iPrivacyResponseTimer->IsActive());

	}

void CPrivacyNotifierHandler::WaitForPrivacyResponse()

	{

	// Start a timeout timer, in case the privacy notifier doesn't reply.

	iPrivacyResponseTimer->Cancel();

	TUint privacyVerifyTimeoutInMilliSeconds = 0;		

	// Note: the following should never fail as we create a default setting in case of absence

	iLbsAdmin.Get(KLbsSettingPrivacyAppTimeout, privacyVerifyTimeoutInMilliSeconds);	

	TTimeIntervalMicroSeconds privacyVerifyTimeout = privacyVerifyTimeoutInMilliSeconds * 1000;

	if (privacyVerifyTimeout > 0)

		{

		iPrivacyResponseTimer->EventAfter(privacyVerifyTimeout, 1);		

		}	

	// flag to show we're waiting for a response