/*

* Copyright (c) 2005 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:  location triggering server client interface

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <lbtstartuptrigger.h>

#include "lbtcontainerao.h"

#include "lbtlisttriggerobserver.h"

#include "lbtupdateasyncoperation.h"

#include "lbtlistasyncoperation.h"

#include "lbtdeleteasyncoperation.h"

#include "lbtcreateasyncoperation.h"

#include "lbtdbtriggersmanager.h"

#include "lbtramtriggersmanager.h"

#include "lbttriggerchangeobserver.h"

#include "lbtcontainer.h"

#include "lbttriggerconditionarea.h"

#include "lbttriggerstoreinterface.h"

#include "lbtcontainerextendedtriggerinfo.h"

#include "lbtlogger.h"

// ================= LOCAL FUNCTIONS ========================

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLbtContainerAO::CLbtContainerAO(RPointerArray<MLbtTriggerStore>& aTriggerStores,

                                 RArray<CLbtContainer::TLbtTriggerStoreChangeObserver>& aObservers ):

								 CActive(EPriorityStandard),

								 iClientStatus(NULL),

								 iAsyncRequest(EOpNone),

								 iTriggerStores(aTriggerStores),

								 iTriggerStoreCtr (0),

								 iObservers(aObservers)

    {   

    CActiveScheduler::Add(this);    

    }

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

// CLbtContainerAO::ConstructL.

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

//

void CLbtContainerAO::ConstructL()

    {

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

    	{

    	iTriggerStores[i]->SetStoreChangeObserver(this);

    	}	

    }

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

// CLbtContainerAO::NewL

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

//

CLbtContainerAO* CLbtContainerAO::NewL(RPointerArray<MLbtTriggerStore>& aTriggerStores,

                                       RArray<CLbtContainer::TLbtTriggerStoreChangeObserver>& aObservers )

    {

    FUNC_ENTER("CLbtContainerAO::NewL");

    CLbtContainerAO* self = new (ELeave) CLbtContainerAO(aTriggerStores,aObservers);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CLbtContainerAO::~CLbtContainerAO

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

//

CLbtContainerAO::~CLbtContainerAO()

    {

    FUNC_ENTER("CLbtContainerAO::~CLbtContainerAO");

	if(IsActive())      

		{

		Cancel();

		}	

	iAsyncOpQueue.ResetAndDestroy();

    }

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

// CLbtContainerAO::AddAsyncOpToQueue

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

//

void CLbtContainerAO::AddAsyncOpToQueue( CLbtContainerAOOperation* aAsyncOp)

    {

    FUNC_ENTER("CLbtContainerAO::AddAsyncOpToQueue");

    // Append to the queue of asynchronous requests.

    if(aAsyncOp)

        {

        iAsyncOpQueue.Append(aAsyncOp);

        // if AO is not active, start serving the current request.

        StartNextAsyncOperation();

        }        

    }

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

// CLbtContainerAO::StartNextAsyncOperation

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

//

void CLbtContainerAO::StartNextAsyncOperation()

    {

    FUNC_ENTER("CLbtContainerAO::StartNextAsyncOperation");

    // Check if any of the trigger stores are busy

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

    	{

    	if(iTriggerStores[i]->IsStoreBusy())

    		{

    		return;

    		}

    	}

    if(!IsActive())

        {

        if(iTriggerStores.Count() > 0)

            {

            iTriggerStoreCtr = -1; 

            iAsyncOpQueue[0]->SetPrevReturnCode(KErrNotReady);

            iAsyncOpQueue[0]->SetCurrentReturnCode(KErrNotReady);

            iAsyncRequest = iAsyncOpQueue[0]->GetAOOperationType();

            }

        else

            {

            TRequestStatus* status = iAsyncOpQueue[0]->GetStatus();

            User::RequestComplete(status,KErrNotSupported);

            return;

            }

        iStatus = KRequestPending;    

        TRequestStatus* status = &iStatus;    

        SetActive();

        /* Do a Self Complete so that the RunL() gets scheduled */

        User::RequestComplete(status,KErrNone);

        }

    }

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

// CLbtContainerAO::GetTriggersL

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

//

void CLbtContainerAO::GetTriggersL( const RArray<TLbtTriggerId>& aTriggerIds,

								    RPointerArray < CLbtContainerTriggerEntry >& aTriggers,

								    TInt& aOpId,

								    TRequestStatus& aStatus,

								    TLbtSecurityPolicy aSecurityPolicy )

	{

	FUNC_ENTER("CLbtContainerAO::GetTriggers");

	CLbtListAsyncOperation* listop = CLbtListAsyncOperation::NewL( aTriggerIds,

    															   aTriggers,

    															   aSecurityPolicy,

    															   aStatus);

    listop->SetOpCode( aOpId );

    AddAsyncOpToQueue( listop );

	}

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

// CLbtContainerAO::ListTriggersL

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

//

void CLbtContainerAO::ListTriggersL( CLbtContainerListOptions* aFilter,

    								 RPointerArray < CLbtContainerTriggerEntry >& aTriggers,

								     TInt aOpCode,

								     TRequestStatus& aStatus,

								     TLbtSecurityPolicy aSecurityPolicy )

    {

    FUNC_ENTER("CLbtContainerAO::ListTriggersL");

    iSortingOption = aFilter->ListOptions()->SortingOption();

    CLbtListAsyncOperation* listop = CLbtListAsyncOperation::NewL( aFilter,

    															   aTriggers,

    															   aSecurityPolicy,

    															   aStatus);

    listop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(listop);

    }

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

// CLbtContainerAO::UpdateTriggerL

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

//    

void CLbtContainerAO::UpdateTriggerL( CLbtContainerTriggerEntry& aEntry,

        							  TLbtTriggerDataMask aDataMask,

        							  TLbtTriggerAttributeFieldsMask aAttrMask,

        							  TInt aOpCode,

        							  TRequestStatus& aStatus,

        							  TLbtSecurityPolicy aSecurityPolicy )

    {

    FUNC_ENTER("CLbtContainerAO::UpdateTriggerL");

    iDataMask = aDataMask;

    iAttrMask = aAttrMask;

    CLbtUpdateAsyncOperation* updateop = CLbtUpdateAsyncOperation::NewL( aEntry,

    																	 aDataMask,

    																	 aAttrMask,

    																	 aStatus,

    																	 aSecurityPolicy,

    																	 EOpUpdateTrigger);

    updateop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(updateop);

    }

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

// CLbtContainerAO::UpdateTriggerL

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

//

void CLbtContainerAO::UpdateTriggerFiredStateL( RArray<TLbtTriggerId>& aTriggerIds,

											    TBool aFireBool,

											    TInt aOpCode,

					                    	    TRequestStatus& aStatus )

	{

	FUNC_ENTER("CLbtContainerAO::UpdateTriggerL - Filter");

	aStatus = KRequestPending;

    CLbtUpdateAsyncOperation* updateop = CLbtUpdateAsyncOperation::NewL( aTriggerIds, 

    																	 aStatus,

    																	 aFireBool,

    																	 KLbtNullSecurity,

    																	 EOpUpdateTriggersFiredState );

    updateop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(updateop);

	}

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

// CLbtContainerAO::UpdateTriggersStateL

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

//

void  CLbtContainerAO::UpdateTriggersStateL( CLbtTriggerEntry::TLbtTriggerState aState,

            								 CLbtContainerUpdateFilter* aFilter,

            								 TInt aOpCode,

            								 TLbtFireOnUpdate aFireOnUpdate,

            								 TRequestStatus& aStatus,

            								 TLbtSecurityPolicy aSecurityPolicy ) 

    {

    FUNC_ENTER("CLbtContainerAO::UpdateTriggersStateL");

    aStatus = KRequestPending;

    CLbtUpdateAsyncOperation* updateop = CLbtUpdateAsyncOperation::NewL( aState,

    																	 aFilter,

    																	 aFireOnUpdate,

    																	 aStatus,    																	 

    																	 aSecurityPolicy,

    																	 EOpUpdateTriggerState);

    updateop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(updateop);

    }

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

// CLbtContainerAO::UpdateTriggersValidityL

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

//            

void CLbtContainerAO::UpdateTriggersValidityL( TLbtTriggerDynamicInfo::TLbtTriggerValidity aValidity,

            								   RArray <TLbtTriggerId>& aTriggerIds,

            								   TInt aOpCode,

            								   TRequestStatus& aStatus,

            								   TLbtSecurityPolicy aSecurityPolicy ) 

    {

    FUNC_ENTER("CLbtContainerAO::UpdateTriggersValidityL");

    CLbtUpdateAsyncOperation* updateop = CLbtUpdateAsyncOperation::NewL( aValidity,

    																	 aTriggerIds,

    																	 aStatus,

    																	 aSecurityPolicy,

    																	 EOpUpdateTriggersValidity);

    updateop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(updateop);

    }

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

// CLbtContainerAO::DeleteTriggersL

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

//    

void CLbtContainerAO::DeleteTriggersL( CLbtContainerUpdateFilter* aFilter,

									   TInt aOpCode,

									   TRequestStatus& aStatus,

									   TLbtSecurityPolicy aSecurityPolicy )

    {

    FUNC_ENTER("CLbtContainerAO::DeleteTriggersL");

    CLbtDeleteAsyncOperation* deleteop = CLbtDeleteAsyncOperation::NewL(aFilter, aStatus, aSecurityPolicy);

    deleteop->SetOpCode(aOpCode);

    AddAsyncOpToQueue(deleteop);

    }

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

// CLbtContainerAO::CreateTriggerL

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

//    

void CLbtContainerAO::CreateTriggerL(CLbtContainerTriggerEntry* aEntry,TInt aOpCode,TRequestStatus& aStatus) 

 	{

 	FUNC_ENTER("CLbtContainerAO::CreateTriggerL");

 	CLbtCreateAsyncOperation* createop = CLbtCreateAsyncOperation::NewL(aEntry,aStatus);

 	createop->SetOpCode(aOpCode);

 	AddAsyncOpToQueue(createop);	

 	}

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

// CLbtContainerAO::RunL

//

// (other items were commented in a header).

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

//

void CLbtContainerAO::RunL()

    {

    FUNC_ENTER("CLbtContainerAO::RunL");

   	TInt error=iStatus.Int();

   	if( error == KErrCancel )

   		{

   		if( iAsyncOpQueue.Count() > 0 )

			{

			StartNextAsyncOperation();

			}

		return;

   		}

   	if(iTriggerStoreCtr < iTriggerStores.Count() - 1)

   	    {

        iTriggerStoreCtr++;

        if(iTriggerStoreCtr == 0)

            {             

            iAsyncOpQueue[0]->StartAOOperationL( iTriggerStores[iTriggerStoreCtr],iStatus); 

            SetActive();

            }

        else if(iTriggerStoreCtr == 1)

            {

            if(error == KErrNone || error == KErrNotFound)

                {

                iAsyncOpQueue[0]->SetCurrentReturnCode(error);                

                iAsyncOpQueue[0]->StartAOOperationL( iTriggerStores[iTriggerStoreCtr],iStatus);

                SetActive();                

                }

            else 

                {

                CompleteAsyncRequest(error);

                if(iAsyncOpQueue.Count()>0)

   	                {

           	        StartNextAsyncOperation();

                    }

                }

            }

        else if(iTriggerStoreCtr>1)

            {

            TInt prevError = iAsyncOpQueue[0]->GetPrevReturnCode();

            TInt currError = iAsyncOpQueue[0]->GetCurrentReturnCode();

            /* if previous error is KErrNotFound and current is KErrNone

             * then make previous as KErrNone 

             * else  if prev is KErrNone, that means that the operation has

             * succeeded in atleast one trigger store so,

             * let the prev code remain KErrNone

             * even if the currErr is KErrNotFound

             */

            if((prevError == KErrNotFound || prevError == KErrNotReady) && (currError == KErrNone || currError == KErrNotReady))

                {

                iAsyncOpQueue[0]->SetPrevReturnCode(currError);

                }

            /* Now once the prev code is modified, set the current code

             * to the one this operation returned.

             */

            iAsyncOpQueue[0]->SetCurrentReturnCode(error);

            TInt prevCode,currCode;

            prevCode = iAsyncOpQueue[0]->GetCurrentReturnCode();

            currCode = iAsyncOpQueue[0]->GetPrevReturnCode();

            /* Start the operation with the next trigger store only if

             * both the prevCode and CurrCode  are KErrNone or KErrNotFound

             * else complete the request with the error code

             */

            if(((prevCode == KErrNotFound) ||( prevCode == KErrNone) || (prevCode == KErrNotReady))&&(currCode == KErrNotFound || currCode == KErrNone))

                {

                 if(iTriggerStoreCtr<iTriggerStores.Count())

                    {

                    iAsyncOpQueue[0]->StartAOOperationL( iTriggerStores[iTriggerStoreCtr],iStatus);

                    SetActive();   

                    }

                  else

                    {

                    CompleteAsyncRequest(currCode);

                    if(iAsyncOpQueue.Count()>0)

   	                    {

               	        StartNextAsyncOperation();

                        }

                    } 

                }

            else

                {

                CompleteAsyncRequest(currCode);

                 if(iAsyncOpQueue.Count()>0)

   	                {

           	        StartNextAsyncOperation();

                    }

                }

            }

   	    }

   	else

   	    {

        TInt prevCode = iAsyncOpQueue[0]->GetPrevReturnCode();

        TInt currCode = iAsyncOpQueue[0]->GetCurrentReturnCode();    

        if(prevCode == KErrNone || currCode == KErrNone || error == KErrNone)

            {

            CompleteAsyncRequest(KErrNone);

            }

        else 

            {

            CompleteAsyncRequest(error);

            }   

   	    if(iAsyncOpQueue.Count()>0)

   	        {

   	        StartNextAsyncOperation();

   	        }

   	    }    

    }

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

// CLbtContainerAO::CompleteAsyncRequest

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

//

void CLbtContainerAO::CompleteAsyncRequest(TInt aErr)

    {

    FUNC_ENTER("CLbtContainerAO::CompleteAsyncRequest");

    CLbtContainerAOOperation* asyncObjPtr = iAsyncOpQueue[0];    

    if( (iAsyncRequest == EOpCreateTrigger) && 

        (aErr == KErrNone) )

		{

		CLbtCreateAsyncOperation* createop = static_cast <CLbtCreateAsyncOperation*> (asyncObjPtr);

		RArray<TLbtTriggerId> triggerIds;

		CLbtContainerTriggerEntry* entry = const_cast<CLbtContainerTriggerEntry*>(createop->ContainerTriggerEntry());

   		TLbtTriggerEventMask eventMask;

   		// Append the manager uids and owner uids into the array

   		RArray<TUid> managerui;

   		TUid ownerUid;

   		ownerUid.iUid = (TInt)( entry->ExtendedTriggerInfo()->OwnerSid().iId);

   		managerui.Append( ownerUid );

   		if( entry->TriggerEntry()->Type() == CLbtTriggerEntry::ETypeStartup )

   			{

   			CLbtStartupTrigger* startupTrigger = static_cast<CLbtStartupTrigger*>(entry->TriggerEntry());

			TSecureId secureId;

			TBuf16<KMaxFileName> fileName;

			startupTrigger->GetProcessId(fileName, secureId);

			TUid startupUid;

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

			if( startupUid != KNullUid )

				{				

				managerui.Append( startupUid );

				}

   			}   		

   		// Give the observer callback through interface

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

			{

			TInt isRequested = EFalse;	

			ProcessFilter(isRequested,iObservers[i].iEventMask,eventMask);

			if(isRequested)

				{

				MLbtContainerChangeEventObserver::TLbtContainerChangedAreaType changeType = 

										MLbtContainerChangeEventObserver::ETypeUnKnown;

				const CLbtTriggerConditionArea* conditionBase = 

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

				if(conditionBase)

					{

					CLbtGeoAreaBase* areaBase = conditionBase->TriggerArea();

					if(areaBase)

						{

						CLbtGeoAreaBase::TGeoAreaType areaType = areaBase->Type();

						if(areaType == CLbtGeoAreaBase::ECircle)

							{

							changeType = MLbtContainerChangeEventObserver::ETypeCircularTriggerChange;

							}

						else if(areaType == CLbtGeoAreaBase::ECellular)

							{

							changeType = MLbtContainerChangeEventObserver::ETypeCellularTriggerChange;

							}

						else

							{

							changeType = MLbtContainerChangeEventObserver::ETypeRectangularTriggerChange;

							}

						}					

					}				

				//Ownership of triggersModified array is transferred to the client