/*

* Copyright (c) 2002 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:    Test module to implement Test cases for BC

*

*/

// INCLUDE FILES

#include "AsynOperationAO.h"

//#include <lbtoperation.h>

#include <flogger.h>

_LIT(KLbtTraceDir,"epos");

 _LIT(KLbtTraceFile,"TriggerFireInfo.log");

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

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

// CTriggerFireObserver::CTriggerFireObserver

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

// might leave.

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

//

CTriggerFireObserver::CTriggerFireObserver(  ): 

CTimer( CTimer::EPriorityStandard ),iWait(NULL)

    {

        CActiveScheduler::Add(this);

    }

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

// CTriggerFireObserver::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTriggerFireObserver::ConstructL( RLbt& aLbt )

    {

     	iTriggerFireCount =0;

     	CTimer::ConstructL();

     	iNotifier = CLbtTriggerFiringEventNotifier::NewL( aLbt,*this );

    }

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

// CTriggerFireObserver::NewL

// Two-phased constructor.

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

//

CTriggerFireObserver* CTriggerFireObserver::NewL( RLbt& aLbt)

    {

	    CTriggerFireObserver* self = new (ELeave) CTriggerFireObserver(  );

	    CleanupStack::PushL( self );

	    self->ConstructL( aLbt );

	    CleanupStack::Pop();

	    return self;

    }

// Destructor

CTriggerFireObserver::~CTriggerFireObserver()

    { 

	    Cancel(); 

	    // Delete notifier object

	    delete iNotifier;

	    delete iWait;

	   // iWait=NULL;

    }

void CTriggerFireObserver::TriggerFiredL( const TLbtTriggerFireInfo& aFireInfo )

	{

	    RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Trigger FiredL called "));

	    iTriggerFireCount++;

	    iWaitStatus =0;

	    iFireInfo=aFireInfo;

	     if( iWait->IsStarted() )

	    {

	      RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "TriggerFiredL wait stopped "));

	      iWait->AsyncStop( );	

	    }

		CheckPositionInfoL( aFireInfo );

	}

void CTriggerFireObserver::StartNotification( CActiveSchedulerWait* aWait )

	{

	  	iWait=aWait;

	  	iNotifier->Start( );

	}

void CTriggerFireObserver::CancelNotification( )

	{

	   	iNotifier->Cancel( );

	}

void CTriggerFireObserver::RunL( )

    {

        RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "CTriggerFireObserver::RunL called "));

        error = iStatus.Int();

         if( iWait->IsStarted() )

	    {

	    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "RunL wait stopped "));

        iWait->AsyncStop( );

	    }

    }

void CTriggerFireObserver::DoCancel( )

    {

    }

void CTriggerFireObserver::CheckPositionInfoL( const TLbtTriggerFireInfo& /*aFireInfo*/ )

    {

    }

TInt CTriggerFireObserver::GetFireCount( ) 

{

	return iTriggerFireCount;

}

TInt CTriggerFireObserver::GetError( ) 

{

	return error;

}

TLbtTriggerFireInfo CTriggerFireObserver::GetFiredTrigger( ) 

{

	return iFireInfo;

}

void CTriggerFireObserver::CreateTriggers( RLbt& aLbt,

                                           CLbtTriggerEntry& aEntry,

                                           TLbtTriggerId& aId,

                                           TBool aFireOnCreation,

                                           CActiveSchedulerWait* aWait 

                                         )   

{

    iWait=aWait;	

	aLbt.CreateTrigger( aEntry,aId,aFireOnCreation,iStatus );

	SetActive( ); 

}

void CTriggerFireObserver::GetTriggersList(RLbt& aLbt, RPointerArray < CLbtTriggerInfo >& aTriggerList,

            CActiveSchedulerWait* aWait,CLbtListTriggerOptions* aListOptions )   

{

    iWait=aWait;	

	aLbt.GetTriggers(iStatus,aTriggerList,aListOptions);

	SetActive( ); 

}

void CTriggerFireObserver::ListTriggerIdsList(RLbt& aLbt, RArray < TLbtTriggerId >& aTriggerIdList,

            CActiveSchedulerWait* aWait,CLbtListTriggerOptions* aListOptions)   

{

    iWait=aWait;	

	aLbt.ListTriggerIds(iStatus,aTriggerIdList,aListOptions);

	SetActive( ); 

}

void CTriggerFireObserver::CreateIterator(RLbt& aLbt, 

            CActiveSchedulerWait* aWait,CLbtListTriggerOptions* aListOptions)   

{

    iWait=aWait;	

	aLbt.CreateGetTriggerIterator(iStatus,aListOptions);

	SetActive( ); 

}

//  End of File

void CTriggerFireObserver::DeleteFilteredTriggers( RLbt& aLbt,

                                                     CLbtTriggerFilterBase* aFilter,

                                                     CActiveSchedulerWait* aWait 

                                                   )

	{

	  iWait=aWait;

	  aLbt.DeleteTriggers(iStatus,aFilter);

	  SetActive();

	}

void CTriggerFireObserver::PopulateFromCurrentCell(CLbtGeoCell& /*cell*/,CActiveSchedulerWait* aWait )	

{

	iWait=aWait;

	//cell.PopulateFromCurrentCellL(iStatus);

	SetActive();

}

void CTriggerFireObserver::UpdateTriggersState(RLbt& aLbt, CLbtTriggerEntry::TLbtTriggerState aState ,

            CActiveSchedulerWait* aWait, CLbtTriggerFilterBase *  aFilter)   

{

    iWait=aWait;	

	aLbt.SetTriggersState(iStatus,aState,ELbtTrue,aFilter);

	SetActive( ); 

}

/*CLBTOperation * CTriggerFireObserver::CreateGeoAreaForCurrentLocationL( CLbtGeoAreaBase::TGeoAreaType aTechType,

																        CLbtGeoAreaBase ** aArea,

																        CActiveSchedulerWait* aWait )

{

	iWait=aWait;

	CLBTOperation* operation;

	operation = CLBTOperation::CreateGeoAreaForCurrentLocationL(iStatus,aTechType,aArea);

	if(operation != NULL)

		SetActive( ); 

	return operation;

}*/

void CTriggerFireObserver::DeleteTriggersById( RLbt& aLbt,

                                                 const RArray< TLbtTriggerId >& aTriggerIdList,

                                                 CActiveSchedulerWait* aWait 

                                               )

	{

	  iWait=aWait;

	  aLbt.DeleteTriggers( aTriggerIdList,iStatus );

	  SetActive(); 	

	}

void CTriggerFireObserver::NotifyTriggerFired(RLbt& aLbt, TLbtTriggerFireInfo& aFireInfo,CActiveSchedulerWait* aWait)

{

	iWait=aWait;	

	aLbt.NotifyTriggerFired(aFireInfo,iStatus);

	SetActive( ); 

}

void CTriggerFireObserver::NotifyTriggeringSettingsChange( RLbt& aLbt,TLbtTriggeringSystemSettings &  aSettings,TLbtTriggeringSystemSettings /*dummySettings*/,CActiveSchedulerWait* aWait

                                                         )   

{

	iWait = aWait;

    //iSettingsChangeReqIssued=ETrue;

   // iSettings=dummySettings;

    aLbt.NotifyTriggeringSystemSettingChange( aSettings,iStatus );

	SetActive( ); 

}

void CTriggerFireObserver::UpdateTrigger(RLbt& aLbt,CLbtTriggerEntry& aTrigger,TLbtTriggerAttributeFieldsMask aFieldMask,CActiveSchedulerWait* aWait,

            TLbtFireOnUpdate aFireOnUpdate) 

{

	iWait=aWait;	

	aLbt.UpdateTrigger(aTrigger,aFieldMask,aFireOnUpdate,iStatus );    

	SetActive( ); 

}

void CLbtEventObserver::NotifyTriggerChangeEvent( RLbt& aLbt,TLbtTriggerChangeEvent& aEvent ,CActiveSchedulerWait* aWait )   

	{

		iWait = aWait;

		aLbt.NotifyTriggerChangeEvent(aEvent,iStatus );

		SetActive( ); 

	}

void CLbtEventObserver::NotifyTriggerChangeEvent2L( RLbt& aLbt,CActiveSchedulerWait* aWait )   

	{

		iWait = aWait;

	    itrigchangenotifier= CLbtTriggerChangeEventNotifier ::NewL( aLbt,*this );

		itrigchangenotifier->Start();

	}

void CLbtEventObserver::NotifyTriggeringsettingsChangeEventL( RLbt& aLbt,CActiveSchedulerWait* aWait )   

	{

		iWait = aWait;

	    isettingschangenotifier= CLbtTriggeringSystemSettingsChangeEventNotifier::NewL( aLbt,*this);

		isettingschangenotifier->Start();

	}		

void CLbtEventObserver::TriggeringsettingsChangeEventDestructor()   

	{

	isettingschangenotifier->~CLbtTriggeringSystemSettingsChangeEventNotifier();

	}

void CLbtEventObserver::TriggerChangeEventDestructor()   

	{

	itrigchangenotifier->~CLbtTriggerChangeEventNotifier();

	}		

/*void CLbtEventObserver::NotifyTriggerChangeEvent( RLbtManager& aLbtmanager,TLbtTriggerChangeEvent& aEvent ,CActiveSchedulerWait* aWait )   

	{

		iWait = aWait;

		aLbtmanager.NotifyTriggerChangeEvent(aEvent,iStatus );

		SetActive( ); 

	}

*/

CLbtEventObserver::CLbtEventObserver(  ) :

CTimer( CTimer::EPriorityStandard ),iWait(NULL)

    {

        CActiveScheduler::Add(this);

    }

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

// CTriggerFireObserver::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLbtEventObserver::ConstructL( RLbt& /*aLbt*/ )

    {

     //	CTimer::ConstructL();

     //	iNotifier = CLbtTriggerFiringEventNotifier::NewL( aLbt,*this );

    // RFileLogger aLog;

    // iCidchangenotifier=CLbtCidChangeNotifier::NewL(aLog,this);

    }

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

// CTriggerFireObserver::NewL

// Two-phased constructor.

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

//

CLbtEventObserver* CLbtEventObserver::NewL( RLbt& aLbt)

    {

    CLbtEventObserver* self = new (ELeave) CLbtEventObserver(  );

	    CleanupStack::PushL( self );

	    self->ConstructL( aLbt );

	    CleanupStack::Pop();

	    return self;

    }

// Destructor

CLbtEventObserver::~CLbtEventObserver()

    { 

	//		RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "~CLbtEventObserver before Cancel"));

	    Cancel(); 

	//    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "~CLbtEventObserver After Cancel "));

	    // Delete notifier object

    //	delete iCidchangenotifier;

    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "~CLbtEventObserver iCidchangenotifier deleted "));

    	delete iWait;

    	delete itrigchangenotifier;

    	delete isettingschangenotifier;

    //		RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "iWait deleted "));

	   // iWait=NULL;

    }

void CLbtEventObserver::RunL( )

    {

       RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "CLbtEventObserver::RunL called "));

        if( iWait && iWait->IsStarted() )

	    {

	      RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "RunL wait stopped "));

	      iWait->AsyncStop( );	

	    }

    }

void CLbtEventObserver::DoCancel( )

    {

    }

    void CLbtEventObserver::CreateTriggers( RLbt& aLbt,

                                           CLbtTriggerEntry& aEntry,

                                           TLbtTriggerId& aId,

                                           TBool aFireOnCreation,

                                           CActiveSchedulerWait* aWait 

                                         )   

{

    iWait=aWait;	

	aLbt.CreateTrigger( aEntry,aId,aFireOnCreation,iStatus );

	SetActive( ); 

}

void CLbtEventObserver::TriggerChangedL( const TLbtTriggerChangeEvent& aEvent )

	{

	   iEvent = aEvent;

	    if(aEvent.iEventType == ELbtTriggerChangeEventCreated)

	    {

	    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Trigger Created "));

	    }

	    else if(aEvent.iEventType == ELbtTriggerChangeEventDeleted)

	    {

	    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Trigger Deleted "));

	    }

	    else if(aEvent.iEventType == ELbtTriggerChangeEventUpdated)

	    {

	    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Trigger Deleted "));

	    }

	    else if(aEvent.iEventType == ELbtTriggerChangeEventMultiple)

	    {

	    	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Multiple Events "));

	    }

	     if( iWait->IsStarted() )

	    {

	      RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "TriggerFiredL wait stopped "));

	      iWait->AsyncStop( );	

	    }

	}

void CLbtEventObserver::TriggeringSystemSettingsChangedL( const TLbtTriggeringSystemSettings& aSettings )

	{

	   iSettings = aSettings;

	     if( iWait->IsStarted() )

	    {

	      RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "TriggerFiredL wait stopped "));

	      iWait->AsyncStop( );	

	    }

	}	

/*void CLbtEventObserver::HandleCIDChangeL(const CTelephony::TNetworkInfoV1 &aNwInfo)

    { 

//	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Network mode = %d"),aNwInfo.iMode);

//	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Country code = %s"),aNwInfo.iCountryCode);

//	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Network id = %s"),aNwInfo.iNetworkId);

	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Location Area code= %d"),aNwInfo.iLocationAreaCode);

	RFileLogger::WriteFormat(KLbtTraceDir, KLbtTraceFile, EFileLoggingModeAppend,_L( "Cell Id= %d"),aNwInfo.iCellId);

    }

    void CLbtEventObserver::StartCidNotification( CActiveSchedulerWait* aWait )

	{

	  	iWait=aWait;

	  	iCidchangenotifier->Start();

	}*/