/*

* Copyright (c) 2006, 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:  Implementation of Trigger View

*

*/

#include <lbtlisttriggeroptions.h>

#include "lbtlogger.h"

#include "lbttriggerview.h"

#include "lbttriggerconditionarea.h"

#include "lbtgeohybrid.h"

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

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

// CLbtTriggerView::NewL

// 

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

//

CLbtTriggerView* CLbtTriggerView::NewL( MLbtTriggerViewObserver* aObserver )

    {    

    FUNC_ENTER("CLbtTriggerView::NewL");

    CLbtTriggerView* self = new ( ELeave ) CLbtTriggerView;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop();

    return self;

    }

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

// CLbtTriggerView::CheckRefreshRequests

// 

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

//

void CLbtTriggerView::CheckRefreshRequests()

    {

    FUNC_ENTER("CLbtTriggerView::CheckRefreshRequests");

    if( iRefRequestList.Count() > 0 )

        {

        iState = ERefreshView;

        SetEvent();

        }

    else

        {

        // switch back to idle state

        iState = EIdle;

        }

    }

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

// CLbtTriggerView::Refresh

// 

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

//

void CLbtTriggerView::Refresh( TPositionInfo& aPosInfo, 

                               TLbtTriggerEventMask aEventMask,

                               RArray<TLbtTriggerId>& aTriggerID )

    {

    FUNC_ENTER("CLbtTriggerView::Refresh");

        // Append refresh requests to the queue to be processed by trigger view

        if( aTriggerID.Count() != 0 )

            {            

            TRefRequestParam req;

            req.posInfo = aPosInfo;

            req.eventMask = aEventMask;

            RArray< TLbtTriggerId >* triggerID = NULL;

            TRAPD( err,  triggerID = 

                new( ELeave ) RArray< TLbtTriggerId > );

            if( KErrNone == err )

                {

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

                    {

                    triggerID->Append( aTriggerID[i] );

                    }

                req.triggerID = triggerID;

                }

            else

                {

                // Memory allocation failure

                LOG1("Mem Error: %d", err);

                // ToDo: Initiate termination

                return;

                }

            iRefRequestList.Append( req );

            }

        LOG1( "View State is %d", iState );

        // Initiate processing of request queue only if the current state is

        // idle. Processing of subsequent requests is automatically handled 

        // by the ProcessRefreshRequests() method when state is ERefreshView

        if( EIdle == iState )

            {

            LOG("Resetting modified trigger list");

            iModifiedTrgList.Reset();

            iState = ERefreshView;

            SetEvent();

            }

    }

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

// CLbtTriggerView::GetModifiedTriggers

// 

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

//

void CLbtTriggerView::GetModifiedTriggers( RArray< TLbtTriggerId >& aList )

    {

    FUNC_ENTER("CLbtTriggerView::GetModifiedTriggers");

    for( TInt index = 0; index < iModifiedTrgList.Count(); index++ )

        {

        aList.Append( iModifiedTrgList[index] );

        }

    // This is done here because strategy engine invokes this method and evaluates all modified triggers

    iModifiedTrgList.Reset();

    }

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

// CLbtTriggerView::GetTriggerByID

// 

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

//

TBool CLbtTriggerView::GetTriggerByID( TLbtTriggerId aID, 

                                     CLbtContainerTriggerEntry*& aTriggerInfo )

    {

    FUNC_ENTER("CLbtTriggerView::GetTriggerByID");

    TBtreePos pos;

    TBool found = EFalse;

    TRAPD( err, 

        found = iTriggerList->FindL( pos, aID ); 

        if( found )

            {

            TTrigger tEntry;

            iTriggerList->ExtractAtL( pos, tEntry );

            aTriggerInfo = tEntry.info;

            } 

    );

    if( KErrNone != err )

        {

        found = EFalse;

        }

    return found;

    }

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

// CLbtTriggerView::IsEmpty

// 

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

//

TBool CLbtTriggerView::IsEmpty()

    {

    return iTriggerList->IsEmpty();

    }

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

// CLbtTriggerView::SetContainerObserver

// 

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

//

void CLbtTriggerView::SetContainerObserver( 

                                MLbtContainerChangeEventObserver* aObserver )

    {

    FUNC_ENTER("CLbtTriggerView::SetContainerObserver");

    // Set observer for trigger change notifications from container

    TLbtTriggerEventMask event = CLbtContainer::ELbtConTriggerEnabledAndValidCreated | 

		                         CLbtContainer::ELbtConTriggerDeleted |

		                         CLbtContainer::ELbtConTriggerStateFieldChanged |

		                         CLbtContainer::ELbtConTriggerConditionFieldChanged |

		                         CLbtContainer::ELbtConTriggerValidityFieldChanged;

    iTrgContainer->SetChangeObserver( aObserver, event );

    iContainerObserver = aObserver;    

    }

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

// CLbtTriggerView::SetTriggerStatusObserver

// 

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

//

void CLbtTriggerView::SetTriggerStatusObserver( 

                                MLbtTriggerStatusObsrvr* aObserver )

    {

    FUNC_ENTER("CLbtTriggerView::SetTriggerStatusObserver");

    iTriggerStatusObserver = aObserver;

    }

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

// CLbtTriggerView::UpdateTriggerInfo

// 

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

//

void CLbtTriggerView::UpdateTriggerInfo( CLbtGeoAreaBase::TGeoAreaType aAreaType,

                                         TPositionInfo aPosInfo,

                                         CLbtContainerTriggerEntry* aTrigger, 

                                         TLbtTriggerDataMask aDataMask )

    {

    FUNC_ENTER("CLbtTriggerView::UpdateTriggerInfo");

    TUpdateRequestParam reqParam;

    reqParam.areaType = aAreaType;

    reqParam.posInfo = aPosInfo;

    reqParam.trigger = aTrigger;

    reqParam.dataMask = aDataMask;

    iUpdateRequestList.Append( reqParam );

    if( EIdle == iState )

        {

        iState = ERefreshContainer;

        SetEvent();

        }

    }

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

// CLbtTriggerView::RemContainerObserver

// 

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

//

void CLbtTriggerView::DetermineNearestTriggerChanges( RArray< TNearestTrigger >* aNearestTriggers )

    {

    FUNC_ENTER("CLbtTriggerView::DetermineNearestTriggerChanges");

    TLinearOrder< TLbtTriggerId > byTriggerID( CompareByID );

    TInt pos = 0;

    TInt count = aNearestTriggers->Count();

    for( TInt index = count - 1; index >= 0; index-- )

        {

        pos = iModifiedTrgList.FindInOrder( ( *aNearestTriggers )[0].id, byTriggerID );

        if( KErrNotFound != pos )

            {

            aNearestTriggers->Remove( index );

            }

        }

    }

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

// CLbtTriggerView::RemContainerObserver

// 

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

//

void CLbtTriggerView::RemContainerObserver()

    {

    FUNC_ENTER("CLbtTriggerView::RemContainerObserver");

    iTrgContainer->RemoveObserver( iContainerObserver );

    }

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

// CLbtTriggerView::InvalidateTrigger

// 

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

//

void CLbtTriggerView::InvalidateTrigger( TLbtTriggerId aKey )

    {

    FUNC_ENTER("CLbtTriggerView::InvalidateTrigger");

    TBtreePos pos;

    TBool found = EFalse;

    TRAPD( err, 

        found = iTriggerList->FindL( pos, aKey );

        if( found )

            {

            TTrigger tEntry;

            iTriggerList->ExtractAtL( pos, tEntry );

            tEntry.validity = EFalse;

            // Remove entry from tree and re-insert the modified entry

            iTriggerList->DeleteL( aKey );

            iTriggerList->InsertL( pos, tEntry );

            } 

    );

    if( KErrNone != err )

        {

        LOG1("Invalidation of trigger %d failed",aKey );

        LOG1("Reason: %d", err);

        }

    else

        {

        LOG1("Trigger %d will no longer be supervised as it is invalidated", aKey);

        }

    }

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

// CLbtTriggerView::BeginL

// 

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

//

CLbtTriggerView::TTriggerViewIter CLbtTriggerView::BeginL(CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea)

    {

    FUNC_ENTER("CLbtTriggerView::BeginL");

     TTriggerViewIter iter = TTriggerViewIter( iTriggerList,aPrimaryTriggerArea );

     TInt err = iter.Reset();

     if( KErrNone != err && KErrNotFound != err )

        {

        User::Leave( err );

        }

     return iter;

    }

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

// CLbtTriggerView::BeginL

// 

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

//

CLbtTriggerView::TTriggerViewIter CLbtTriggerView::BeginL(CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea,

                                                          CLbtGeoAreaBase::TGeoAreaType aSecondaryTriggerArea)

    {

    FUNC_ENTER("CLbtTriggerView::BeginL");

     TTriggerViewIter iter = TTriggerViewIter( iTriggerList,aPrimaryTriggerArea,

                                               aSecondaryTriggerArea);

     TInt err = iter.Reset();

     if( KErrNone != err && KErrNotFound != err )

        {

        User::Leave( err );

        }

     return iter;

    }

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

// CLbtTriggerView::Begin

// 

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

//

CLbtTriggerView::TTriggerViewIter CLbtTriggerView::Begin( 

                                                RArray< TLbtTriggerId >* aID,

                                                CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea)

    {

    FUNC_ENTER("CLbtTriggerView::CLbtTriggerView::Begin");

    TTriggerViewIter iter = TTriggerViewIter( iTriggerList, aID ,aPrimaryTriggerArea );

    ( void )iter.Reset();

    return iter;

    }

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

// CLbtTriggerView::~CLbtTriggerView

// 

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

//

CLbtTriggerView::~CLbtTriggerView()

    {

    FUNC_ENTER("CLbtTriggerView::~CLbtTriggerView");

    TBtreeMark index;

    TBool next = EFalse;

    if (IsActive())

        {

        Cancel();

        }

    if( NULL != iTriggerList )

        {

        TRAPD( err, 

        next = iTriggerList->ResetL( index );

        TTrigger tEntry;

        while( next ) 

            {

            iTriggerList->ExtractAtL( index, tEntry );

            delete tEntry.info;

            iTriggerList->DeleteL( tEntry.key );

            next = iTriggerList->ResetL( index );

            } );

        if( KErrNone != err )

            {

            }

        }

    iList.ResetAndDestroy();

    delete iTriggerList;

    delete iPool;

    if( NULL != iTrgContainer )

        {

        iTrgContainer->Destroy();

        }

    iModifiedTrgList.Close();

    iUpdateRequestList.Close();

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

    	{

    	if( iRefRequestList[i].triggerID != NULL )

    		{

    		iRefRequestList[i].triggerID->Close();

    		delete (iRefRequestList[i].triggerID);

    		}    	

    	}

    iRefRequestList.Close();

    }

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

// CLbtTriggerView::TTriggerViewIter::TTriggerViewIter

// 

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

//

CLbtTriggerView::TTriggerViewIter::TTriggerViewIter()

    {

    }

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

// CLbtTriggerView::TTriggerViewIter::TTriggerViewIter

// 

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

//

CLbtTriggerView::TTriggerViewIter::TTriggerViewIter( 

                           TBtreeFix< TTrigger, TLbtTriggerId >* aTriggerList,

                           CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea )

    {

    FUNC_ENTER("CLbtTriggerView::TTriggerViewIter");

    iTrgArray = NULL;

    iLast = ETrue;    

    iTree = aTriggerList;

    iPrimaryAreaType = aPrimaryTriggerArea;

    }

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

// CLbtTriggerView::TTriggerViewIter::TTriggerViewIter

// 

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

//

CLbtTriggerView::TTriggerViewIter::TTriggerViewIter( 

                           TBtreeFix< TTrigger, TLbtTriggerId >* aTriggerList,

                           CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea,

                           CLbtGeoAreaBase::TGeoAreaType aSecondaryTriggerArea)

    {

    FUNC_ENTER("CLbtTriggerView::TTriggerViewIter");

    iTrgArray = NULL;

    iLast = ETrue;    

    iTree = aTriggerList;

    iPrimaryAreaType = aPrimaryTriggerArea;

    iSecondaryAreaType = aSecondaryTriggerArea;

    }

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

// CLbtTriggerView::TTriggerViewIter::TTriggerViewIter

// 

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

//

CLbtTriggerView::TTriggerViewIter::TTriggerViewIter( 

                                TBtreeFix< TTrigger, TLbtTriggerId >* aTriggerList,

                                RArray< TLbtTriggerId >* aTriggerIDs,

                                CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea )

    {

    FUNC_ENTER("CLbtTriggerView::TTriggerViewIter");

    iTrgArray = aTriggerIDs;

    iLast = ETrue;    

    iTree = aTriggerList; 

    iPrimaryAreaType = aPrimaryTriggerArea;   

    }

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

// CLbtTriggerView::TTriggerViewIter::TTriggerViewIter

// 

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

//

CLbtTriggerView::TTriggerViewIter::TTriggerViewIter( 

                                TBtreeFix< TTrigger, TLbtTriggerId >* aTriggerList,

                                RArray< TLbtTriggerId >* aTriggerIDs,

                                CLbtGeoAreaBase::TGeoAreaType aPrimaryTriggerArea,

                                CLbtGeoAreaBase::TGeoAreaType aSecondaryTriggerArea)

    {

    FUNC_ENTER("CLbtTriggerView::TTriggerViewIter");

    iTrgArray = aTriggerIDs;

    iLast = ETrue;    

    iTree = aTriggerList; 

    iPrimaryAreaType = aPrimaryTriggerArea;   

    iSecondaryAreaType = aSecondaryTriggerArea;   

    }

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

// CLbtTriggerView::TTriggerViewIter::ResetL

// 

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

//

TInt CLbtTriggerView::TTriggerViewIter::Reset()

    {

    FUNC_ENTER("CLbtTriggerView::Reset");

    if( iTrgArray && iTrgArray->Count() )

        {