/*

* Copyright (c) 2007 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:  Active Object operation for serving server logic requests

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <lbttriggerentry.h>

#include <lbtgeoareabase.h>

#include <lbtgeocircle.h>

#include <lbtgeoareabase.h>

#include <lbttriggerconditionbase.h>

#include <lbttriggerconditionarea.h>

#include <lbttriggerdynamicinfo.h>

#include <s32mem.h>

#include <lbtsessiontrigger.h>

#include <lbtstartuptrigger.h>

#include <lbterrors.h>

#include "lbtcreatetriggeraooperation.h"

#include "lbtaoobserver.h"

#include "lbtserverconsts.h"

#include "lbtglobal.h"

#include "lbtcontainertriggerentry.h"

#include "lbtcontainer.h"

#include "lbtcontainerextendedtriggerinfo.h"

#include "lbtsettingsmanager.h"

#include "lbtlogger.h"

// CONSTANTS

const TInt KCircleRadiusCutoff(500);

const TReal KMinHysteresisArea(20);

// ===================== MEMBER FUNCTIONS =====================

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::NewL

// Symbian Two - phase constructor

// ---------------------------------------------------------------------------

//

CLbtCreateTriggerAOOperation* CLbtCreateTriggerAOOperation::NewL(MLbtAOObserver& aObserver,

															     const RMessage2& aMessage,

															     CLbtContainer& aContainer,

															     TInt aClientType,

															     CLbtSettingsManager& aSettingsManager )

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::NewL");

	CLbtCreateTriggerAOOperation* self = new (ELeave) CLbtCreateTriggerAOOperation(aObserver, 

																				   aMessage, 

																				   aContainer, 

																				   aClientType,

																				   aSettingsManager);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::~CLbtCreateTriggerAOOperation

// Destructor

// ---------------------------------------------------------------------------

//

CLbtCreateTriggerAOOperation::~CLbtCreateTriggerAOOperation()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::~CLbtCreateTriggerAOOperation");

	iContainer.RemoveObserver(this);

	// Call cancel operation

	if( IsActive() )

	    {

	    Cancel();

	    }

	delete iContainerTriggerEntry;

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CLbtCreateTriggerAOOperation

// C++ Default constructor

// ---------------------------------------------------------------------------

//

CLbtCreateTriggerAOOperation::CLbtCreateTriggerAOOperation(MLbtAOObserver& aObserver,

														   const RMessage2& aMessage,

														   CLbtContainer& aContainer,

														   TInt aClientType,

														   CLbtSettingsManager& aSettingsManager)

	: CLbtAOOperationBase(aObserver, aMessage, aContainer, aClientType),

	  iSettingsManager(aSettingsManager)

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::CLbtCreateTriggerAOOperation");

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::ConstructL

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::ConstructL()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::ConstructL");

	CActiveScheduler::Add(this);

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::RunL

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::RunL()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::RunL");	

	switch(iFunction)

		{

		case ELbtCreateTrigger:

			{

			if(iStatus.Int() == KErrNone)

				{

				LOGSTRING("Trigger created: \"%S\" ", &(iContainerTriggerEntry->TriggerEntry()->Name()));

				LOG1("Trigger Id:%d",iContainerTriggerEntry->TriggerEntry()->Id());

				LOG1("Trigger state:%d",iContainerTriggerEntry->TriggerEntry()->State());

				// For create trigger server has to write the trigger id back to the client

				TPckg<TUint32> triggerId(iContainerTriggerEntry->TriggerEntry()->Id());

				LbtGlobal::Write(iMessage, KParamTriggerId,triggerId);

				}

			LbtGlobal::RequestComplete(iMessage, iStatus.Int());			

			break;

			}

		default:

			{

			// Handle the completion of request. Ideally this should not execute

			LbtGlobal::RequestComplete(iMessage, iStatus.Int());

			break;

			}

		}

	iObserver.HandleOperationClosureL(this, iStatus.Int());

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::DoCancel

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::DoCancel()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::DoCancel");

	// Cancel container notifications

	iContainer.CancelAsyncOperation(iAOIdentificationNum);

	iMessage.Complete( iStatus.Int() );

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::StartOperationL

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::StartOperationL()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::StartOperationL");

	switch(iFunction)

		{

		case ELbtCreateTrigger:

			{

			if( CheckTriggerCap() )

				{

				CreateTriggerL();

				}

			else

				{

				LbtGlobal::RequestComplete(iMessage, KLbtErrMaxEnabledValidTriggersLimitExceeded );

				iObserver.HandleOperationClosureL(this, KLbtErrMaxEnabledValidTriggersLimitExceeded );

				}

			break;

			}

		default:

			{

			break;

			}

		}

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CheckTriggerCap()

// ---------------------------------------------------------------------------

//

TBool CLbtCreateTriggerAOOperation::CheckTriggerCap()

	{

	TUint enabledValidTriggerCount = iContainer.GetCountOfEnabledAndValidTriggers();

	if( iSettingsManager.EnabledValidTriggerCount() > enabledValidTriggerCount )

		{

		// More triggers can be created. Return true

		return ETrue;

		}

	return EFalse;

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CreateTriggerL()

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::CreateTriggerL()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::CreateTriggerL");

	// Copy the trigger entry object descriptor from the client IPC message

	HBufC8* triggerEntryBuffer = LbtGlobal::CopyClientBuffer8LC(iMessage, KParamTriggerEntry);

	if( triggerEntryBuffer == NULL )

		{

		iObserver.HandleOperationClosureL(this, KErrBadDescriptor);

		return;

		}

	TLbtTriggerCreationInfo triggerCreationInfo;

	TPckg<TLbtTriggerCreationInfo> des(triggerCreationInfo);

	LbtGlobal::Read(iMessage,2,des);

	// Read the buffer into a stream

	RDesReadStream stream(*triggerEntryBuffer);

	CleanupClosePushL(stream);

	// Create the trigger entry object based on the type of trigger

	CLbtTriggerEntry* trigger;

	if( triggerCreationInfo.iTriggerType== CLbtTriggerEntry::ETypeStartup)

		{

		trigger = CLbtStartupTrigger::NewLC();

		}

	else

		{

		trigger = CLbtSessionTrigger::NewLC();

		}

	// Internalize the trigger entry class since it is a "C" class

	trigger->InternalizeL(stream);	

	// Fill the extended trigger info required by Stratergy

	CLbtExtendedTriggerInfo::TLbtTriggerRectArea area;

	if(trigger->GetCondition()->Type() == CLbtTriggerConditionBase::ETriggerConditionArea)

		{

		// Get the condition area base

		CLbtTriggerConditionArea* conditionArea = 

				static_cast<CLbtTriggerConditionArea*>(trigger->GetCondition());

		// Check if the area is a circle

		if(conditionArea->TriggerArea()->Type() == CLbtGeoAreaBase::ECircle)

			{

			CLbtGeoCircle* circle = static_cast<CLbtGeoCircle*>(conditionArea->TriggerArea());

			// If the triggering area specified is less than the minimum triggering area

			// the return KErrTriggerAreaTooSmall

			if(circle->Radius() < iSettingsManager.MinimumTriggeringArea())

				{

				CleanupStack::PopAndDestroy( 3 ); // trigger,stream,triggerEntry

				LbtGlobal::RequestComplete(iMessage, KErrTriggerAreaTooSmall);

				iObserver.HandleOperationClosureL(this, KErrTriggerAreaTooSmall);

				return;

				}

            CalculateRectangularArea(area, circle);

			}

		}

	// Create the extended trigger info

	CLbtExtendedTriggerInfo* extendedTriggerInfo = 

							CLbtExtendedTriggerInfo::NewL(area,

														  CalculateHysteresisAreaForTrigger(*trigger),

														  EFalse,

														  KNullDesC8,

														  iMessage.SecureId(),

														  triggerCreationInfo.iFireOnCreation);

	CleanupStack::PushL(extendedTriggerInfo);

	TLbtTriggerDynamicInfo* dynInfo = new (ELeave) TLbtTriggerDynamicInfo;

	CleanupStack::PushL(dynInfo);

	dynInfo->iValidity = TLbtTriggerDynamicInfo::EValid;

	// Create trigger class of Container. Container takes ownership of trigger and all info sent to it

	iContainerTriggerEntry = CLbtContainerTriggerEntry::NewL(trigger, dynInfo, extendedTriggerInfo);

	// Register for container change event observer

    TLbtTriggerEventMask eventMask = 0;

    eventMask|= CLbtContainer::ELbtConTriggerCreated;

    iContainer.SetChangeObserver( this ,eventMask );

	// Creates the trigger in the container		

	iContainer.CreateTrigger(*iContainerTriggerEntry,iAOIdentificationNum,iStatus);

	SetActive();

	CleanupStack::Pop(5); //trigger, stream, triggerEntryBuffer, dynInfo and extendedTriggerInfo

	stream.Close();

	delete triggerEntryBuffer;

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CancelCreateTrigger

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::CancelCreateTrigger()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::CancelCreateTrigger");

	Cancel();

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::GetTriggerId

// ---------------------------------------------------------------------------

//

TLbtTriggerId CLbtCreateTriggerAOOperation::GetTriggerId()

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::GetTriggerId");

	return iContainerTriggerEntry->TriggerEntry()->Id();

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CalculateHysteresisAreaForTrigger

// ---------------------------------------------------------------------------

//

TInt CLbtCreateTriggerAOOperation::CalculateHysteresisAreaForTrigger(

    CLbtTriggerEntry& aTrigger)

	{

	FUNC_ENTER("CLbtCreateTriggerAOOperation::CalculateHysteresisAreaForTrigger");

	// The Hysteresis for trigger is calculated as per this formula

	// If radius <= 500 

	//      hysteresis = radius / 4.

	// Else

	//      hysteresis = radius / Ln(radius/10) ( Log to the base e)

	// After the formula 

	// if hysteresis < MinimumHysteresisRadius

	//      hysteresis is taken to be the minimumHysteresis radius.

	// The constant values have to be store in cenrep and read

	// from there.

	TReal hysteresis = 0;

	CLbtTriggerConditionBase* conditionBase = aTrigger.GetCondition();

	TReal radius = 0.0;

	// Fist find the type of the trigger

	if(conditionBase->Type() == 

	                    CLbtTriggerConditionBase::ETriggerConditionArea)

		{

		CLbtTriggerConditionArea* basicCondition = 

		                static_cast<CLbtTriggerConditionArea*>(conditionBase);

		if(basicCondition->TriggerArea()->Type() == CLbtGeoAreaBase::ECircle)

			{

			// The trigger area is circular. Apply hysteresis formula for a circular area

			CLbtGeoCircle* circle = 

			        static_cast<CLbtGeoCircle*>(basicCondition->TriggerArea());

			radius = circle->Radius();

			if(radius > KCircleRadiusCutoff)

				{

				TReal logRadius;				

				Math::Ln(logRadius, radius / 10 );

				hysteresis = radius / logRadius;

				}

			else

				{

				hysteresis = radius / 4;

				}

			}

		}

	if(hysteresis < KMinHysteresisArea)

		{

		hysteresis = KMinHysteresisArea;

		}

	return (hysteresis + radius);

	}

// ---------------------------------------------------------------------------

// CLbtCreateTriggerAOOperation::CalculateRectangularArea

// ---------------------------------------------------------------------------

//

void CLbtCreateTriggerAOOperation::CalculateRectangularArea(

    CLbtExtendedTriggerInfo::TLbtTriggerRectArea& aArea,

    CLbtGeoCircle* aCircle)

    {

    FUNC_ENTER("CLbtCreateTriggerAOOperation::CalculateRectangularArea");

	TCoordinate center = aCircle->Center();

	TCoordinate tmp = center;

	// Get the North Latitude of the ractangular area by moving north

	// (by using a bearing of 0).

	tmp.Move(0, aCircle->Radius());

	aArea.iTrigAreaNorthLat = tmp.Latitude();

	// From the previous point, Move west(by using a bearing of 270).

	// This gives the West Longitude.

	tmp.Move(270,aCircle->Radius());

	aArea.iTrigAreaWestLong = tmp.Longitude();

	// Reset tmp to the center

	tmp = center;

	// Get the South Latitude by moving south

	// (by using a bearing of 180).

	tmp.Move(180, aCircle->Radius());

	aArea.iTrigAreaSouthLat = tmp.Latitude();

	// From the previous point, Move east(by using a bearing of 90).

	// This gives the Eest Longitude.

	tmp.Move(90,aCircle->Radius());

	aArea.iTrigAreaEastLong = tmp.Longitude();

	return;

    }

// end of file