/*

* Copyright (c) 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:  This header file describes the class that handles the storage

*                of triggers in RAM Structures.

*

*/

#include <lbttriggerfilterbyattribute.h>

#include <lbtsessiontrigger.h>

#include <lbtstartuptrigger.h>

#include <lbttriggerfilterbyarea.h>

#include <lbtgeorect.h>

#include <lbttriggerfiltercomposite.h>

#include <lbtgeocircle.h>

#include <lbttriggerconditionarea.h>

#include <lbtgeocell.h>

#include <lbtgeohybrid.h>

#include "lbttriggerstoreobserver.h"

#include "lbtramtriggersmanager.h"

#include "lbtramtriggeridtree.h"

#include "lbtcontainerextendedtriggerinfo.h"

#include "lbtcontainertriggerfilter.h"

#include "lbtcontainerattrfilter.h"

#include "lbtcontainerareafilter.h"

#include "lbtcontainercompfilter.h"

#include "lbtcontainerutilities.h"

#include "lbtserverconsts.h"

#include "lbtlogger.h"

// CONSTANTS

const TInt KStepCount(2); // The step for batch processing of triggers

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

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

// The Symbian 2 phase constructor

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

//

CLbtRamTriggersManager* CLbtRamTriggersManager::NewL( )

    {

    CLbtRamTriggersManager* self = new( ELeave ) CLbtRamTriggersManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CLbtRamTriggersManager::~CLbtRamTriggersManager()

    {

    delete iTriggerIdTree;

    delete iFilterBase;

    iIdArray.Close();

    }

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

// CLbtRamTriggersManager::TriggersModified

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

//

void CLbtRamTriggersManager::TriggersModified(RArray<TLbtTriggerModifiedInfo>& aArray)

	 {

	 for( TInt i = 0;i<iIdArray.Count();i++ )

		 {

		 aArray.Append(iIdArray[i]);	

	     }

	 iIdArray.Reset();

	 }	

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

// Specify the types of triggers supported by the RAM Trigger Store

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

//

TTriggerTypeMask CLbtRamTriggersManager::SupportedTriggerTypes()

    {

    return ( CLbtTriggerEntry::ETypeSession );

    }

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

// CLbtRamTriggersManager::CreateTriggerL

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

//

void CLbtRamTriggersManager::CreateTriggerL( CLbtContainerTriggerEntry &aEntry,

                    					     TRequestStatus& aStatus )

 	{

 	FUNC_ENTER("CLbtRamTriggersManager::CreateTriggerL");

 	aStatus = KRequestPending;

 	// Save client request objects

    iClientStatus = &aStatus;

    iCurrentTriggerId = aEntry.TriggerEntry()->Id();

    iCurrentOperation = EOperationCreate;

 	CLbtContainerTriggerEntry* tEntry = new(ELeave) CLbtContainerTriggerEntry(aEntry);

 	TRAPD(error,iTriggerIdTree->AddToTreeL(tEntry));

    if( error != KErrNone )

        {

        delete tEntry;

        CompleteClientRequest( error );

        }

    else

        {

        // Reliquish control to serve cancel request

        SelfComplete();

        }           

 	}

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

// CreateEntryBasedOnType

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

//

CLbtTriggerEntry* CreateEntryBasedOnType(CLbtTriggerEntry* aEntry) 	

    {

     CLbtTriggerEntry* tEntry = NULL;

     switch(aEntry->Type())

        {

         case CLbtTriggerEntry::ETypeSession: 

         	{

         	TRAP_IGNORE(tEntry = CLbtSessionTrigger::NewL());

         	break;

         	}

         case CLbtTriggerEntry::ETypeStartup:

         	{

         	TRAP_IGNORE(tEntry = CLbtStartupTrigger::NewL());

         	break;

         	}

        }

    return tEntry; 

    }

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

// CLbtRamTriggersManager::GetTriggersL

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

//

void CLbtRamTriggersManager::GetTriggersL( RArray<TLbtTriggerId>& aTriggerIds,

										   RPointerArray<CLbtContainerTriggerEntry>& aTriggers, 

										   TLbtSecurityPolicy& aSecurityPolicy,

										   TRequestStatus &aStatus )

	{

	FUNC_ENTER("CLbtRamTriggersManager::GetTriggersL");

	iClientStatus = &aStatus;

    if( !aTriggerIds.Count() || 

    	iTriggerIdTree->IsEmpty() )

        {

        CompleteClientRequest(KErrNotFound);

        return;

        }

    // Copy trigger id array

    for( TInt i=0;i<aTriggerIds.Count();i++ )

        {

        TLbtTriggerModifiedInfo triggerInfo;

        triggerInfo.iTriggerId = aTriggerIds[i];

        iIdArray.Append( triggerInfo );

        }

    iIterator = 0;    

    iCurrentOperation = EOperationGetTriggers;

    iClientSecurityPolicy = aSecurityPolicy;

    iClientTriggerArray = &aTriggers;

    SelfComplete();

    }

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

// CLbtRamTriggersManager::HandleGetTriggersEventL

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

//

void CLbtRamTriggersManager::HandleGetTriggersEventL()

    {

    TInt count = 0;

    while( (iIterator < iIdArray.Count()) && 

           (count < KStepCount) )

       {

       CLbtContainerTriggerEntry *entry = iTriggerIdTree->FindEntryInTreeL( iIdArray[iIterator].iTriggerId );

       if( entry )

           {

           if( LbtContainerUtilities::RunSecurityPolicy( entry, iClientSecurityPolicy ) )

               {

               CLbtContainerTriggerEntry* clientEntry = new (ELeave) CLbtContainerTriggerEntry( *entry );

               iClientTriggerArray->Append( clientEntry );

               }

           }

       ++iIterator;

       ++count;

       }

    if( iIterator >= iIdArray.Count() )

        {

        // All triggers iteration done. Complete request                

        CompleteClientRequest( KErrNone );

        }

    else

        {

        SelfComplete();                

        }            

    }

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

// CLbtRamTriggersManager::ListTriggersL

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

//

void CLbtRamTriggersManager::ListTriggersL( CLbtContainerListOptions* aFilter,

										    RPointerArray<CLbtContainerTriggerEntry>& aTriggers,

										    TLbtSecurityPolicy& aSecurityPolicy,

										    TRequestStatus &aStatus )

   {

   FUNC_ENTER("CLbtRamTriggersManager::ListTriggersL");

   iClientStatus = &aStatus;

   if(aFilter == NULL)

       {

       CompleteClientRequest( KErrArgument );

       return;

       }

   if( iTriggerIdTree->IsEmpty() )

    	{

    	CompleteClientRequest( KErrNotFound );

        return;

    	}

   CLbtListTriggerOptions* listOptions=aFilter->ListOptions();

   // Store client data 

   iFilter = aFilter;   

   iClientSecurityPolicy = aSecurityPolicy;

   iClientTriggerArray = &aTriggers;

   iCurrentOperation = EOperationListing;

   iFilterBase = LbtContainerUtilities::GetContainerFilterFromListOptionsLC(aFilter);

   CleanupStack::Pop(1); // iFilterBase

   // Set the iterator to point to the first entry in the tree

   iTriggerIdTree->SetIteratorL();

   SelfComplete();

   }

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

// CLbtRamTriggersManager::HandleListTriggerEventL

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

void CLbtRamTriggersManager::HandleListTriggerEventL()

    {    

    CLbtContainerTriggerEntry* tEntry = NULL;

    TInt count = 0;

    while( count < KStepCount )

        {

        tEntry = iTriggerIdTree->GetNextEntryL();

        if( tEntry == NULL )

            break;

        CLbtListTriggerOptions* listOptions = iFilter->ListOptions();

        CLbtContainerFilter* contFilter = iFilter->ContainerFilter();

        CLbtExtendedTriggerInfo* contExtInfo = tEntry->ExtendedTriggerInfo();   

        TLbtTriggerDynamicInfoFieldsMask dynInfoMask;

        TLbtTriggerAttributeFieldsMask attrMask;

        listOptions->GetRetrievedFields(attrMask,dynInfoMask);

        TLbtTriggerDataMask dataMask = iFilter->DataMask();

        ++count;

        if( !LbtContainerUtilities::RunSecurityPolicy( tEntry, iClientSecurityPolicy ) )

            {

            continue;

            }

        CLbtContainerTriggerEntry* entry = NULL;

        CLbtTriggerEntry* clientEntry = NULL;       

        CLbtExtendedTriggerInfo* clientExtInfo = NULL;

        CLbtTriggerEntry* trigEntry = tEntry->TriggerEntry();

        TInt isFilterPresent = 0;

        TBool isEntryRequested = EFalse;

        iFilterBase->ProcessFilter(tEntry, isFilterPresent, isEntryRequested);

        if(isFilterPresent > 0 && isEntryRequested)

            {

            entry = CLbtContainerTriggerEntry::NewL();

            CleanupStack::PushL( entry );

            clientEntry = CLbtSessionTrigger::NewL();

            entry->SetTriggerEntry(clientEntry);

            if( attrMask & CLbtTriggerEntry::EAttributeId )

                {

                clientEntry->SetId(trigEntry->Id());

                }              

            if( attrMask & CLbtTriggerEntry::EAttributeName )

                {

                clientEntry->SetNameL(trigEntry->Name());

                }

            if( attrMask & CLbtTriggerEntry::EAttributeState )

                {           

                clientEntry->SetState(trigEntry->State());

                }

            if( attrMask & CLbtTriggerEntry::EAttributeManagerUi )

                {               

                clientEntry->SetManagerUi(trigEntry->ManagerUi());              

                }

            if( attrMask & CLbtTriggerEntry::EAttributeCondition )

                {

                CLbtTriggerConditionArea* cond = static_cast<CLbtTriggerConditionArea*>(trigEntry->GetCondition());

                // Condition area to be sent back to client

                CLbtTriggerConditionArea* condArea=CLbtTriggerConditionArea::NewL();

                CLbtGeoAreaBase* area = LbtContainerUtilities::CopyGeoAreaL( cond->TriggerArea() );

                condArea->SetTriggerArea( area );

                condArea->SetDirection( cond->Direction() );

                clientEntry->SetCondition( condArea );

                }

            TLbtTriggerDynamicInfo* info = new TLbtTriggerDynamicInfo;

            TBool isDynInfoPresent=EFalse;

            if( dynInfoMask & TLbtTriggerDynamicInfo::EValidityStatus )

                {

                isDynInfoPresent=ETrue;

                info->iValidity=tEntry->DynInfo()->iValidity;

                }

            if( dynInfoMask & TLbtTriggerDynamicInfo::EDistanceToLatestLocation )

                {               

                isDynInfoPresent=ETrue; 

                info->iDistanceToLatestLocation=tEntry->DynInfo()->iDistanceToLatestLocation;

                }

            if( dynInfoMask & TLbtTriggerDynamicInfo::EFiredLocality )

                {

                isDynInfoPresent=ETrue; 

                info->iFiredLocality=tEntry->DynInfo()->iFiredLocality;

                }

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeHysteresisRadius )

                {

                if(clientExtInfo == NULL)

                    {

                    clientExtInfo=CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetHysteresisRadius(contExtInfo->HysteresisRadius());

                }

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeIsFired )

                {

                if(clientExtInfo == NULL)

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetTriggerFiredState(contExtInfo->IsTriggerFired());

                }

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeOwnerSid )

                {

                if(clientExtInfo == NULL)

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }                  

                clientExtInfo->SetOwnerSid(contExtInfo->OwnerSid()); 

                }

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeRectTriggerArea )

                {

                if(clientExtInfo == NULL)

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetTriggerRectangleArea(contExtInfo->TriggerReactangleArea()); 

                }   

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeStrategyData )

                {

                if(clientExtInfo == NULL)                   

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetStrategyDataL(contExtInfo->StategyData()); 

                }

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeIsTriggerFireOnCreation )

                {

                if(clientExtInfo == NULL)

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetTriggerFireOnCreation( contExtInfo->IsTriggerFireOnCreation()); 

                }   

            if( dataMask & CLbtContainerTriggerEntry::EContainerAttributeFireInfo )

                {

                if(clientExtInfo == NULL)                   

                    {

                    clientExtInfo = CLbtExtendedTriggerInfo::NewL();

                    }

                clientExtInfo->SetFiredInfo( contExtInfo->GetFiredInfo()); 

                }

            if(clientExtInfo!=NULL)

                {

                entry->SetExtendedTriggerInfo(clientExtInfo);

                }

            if(isDynInfoPresent)

                {

                entry->SetDynInfo(info);

                }

            if( entry != NULL )

                {

                iClientTriggerArray->Append( entry );

                CleanupStack::Pop( entry );

                }

            }

        }

    if( tEntry == NULL )

        {

        if( iClientTriggerArray->Count() == 0 )

            {

            CompleteClientRequest( KErrNotFound );

            }

        else

            {

            CompleteClientRequest( KErrNone );

            }

        }

    else

        {

        SelfComplete();

        }

    }

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

// CLbtRamTriggersManager::AppendTriggerInfo

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

void CLbtRamTriggersManager::AppendTriggerInfo(CLbtContainerTriggerEntry* aEntry)

	{

	FUNC_ENTER("CLbtRamTriggersManager::AppendTriggerInfo");

	const CLbtTriggerConditionArea* conditionBase = 

			static_cast<const CLbtTriggerConditionArea*>(aEntry->TriggerEntry()->GetCondition());

	CLbtGeoAreaBase* areaBase = conditionBase->TriggerArea();

    TLbtTriggerModifiedInfo info;

    info.iTriggerId = aEntry->TriggerEntry()->Id();

    info.iAreaType = areaBase->Type();

    info.iManagerUi = aEntry->TriggerEntry()->ManagerUi();

    TSecureId sid = aEntry->ExtendedTriggerInfo()->OwnerSid();

    TUid ownerUid;

    ownerUid.iUid = (TInt)(sid.iId);

    info.iOwner = ownerUid;

    CLbtTriggerEntry* triggerEntry = aEntry->TriggerEntry();	

	if( triggerEntry->Type() == CLbtTriggerEntry::ETypeStartup)

		{

		CLbtStartupTrigger* startupTrigger = static_cast<CLbtStartupTrigger*>(triggerEntry);

		TSecureId secureId;

		TBuf16<KMaxFileName> fileName;

		startupTrigger->GetProcessId(fileName, secureId);

		TUid startupUid;

		startupUid.iUid = (TInt)(sid.iId);

		info.iStartupProcess = startupUid;

		}

	else

		{

		info.iStartupProcess = KNullUid;

		}

    iIdArray.Append(info);

	}

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

// CLbtRamTriggersManager::SelfComplete

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

void CLbtRamTriggersManager::SelfComplete()

    {

    FUNC_ENTER("CLbtRamTriggersManager::SelfComplete");

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;    

    SetActive();

    User::RequestComplete(status, KErrNone);    

    }

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

// CLbtRamTriggersManager::RunL

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

void CLbtRamTriggersManager::RunL()

    {

    FUNC_ENTER("CLbtRamTriggersManager::RunL");

    switch( iCurrentOperation )

        {

        case EOperationCreate:

            {

            // See if the trigger is a enabled and valid trigger

            CLbtContainerTriggerEntry *entry = iTriggerIdTree->FindEntryInTreeL( iCurrentTriggerId );

            CLbtTriggerEntry* trigger = entry->TriggerEntry();

            if((trigger->State() == CLbtTriggerEntry::EStateEnabled) &&

               (entry->DynInfo()->iValidity == TLbtTriggerDynamicInfo::EValid))

                {

                iCountOfEnabledAndValidTrigger++;

                }

            CompleteClientRequest( KErrNone );

            break;

            }

        case EOperationUpdateTrigger: