/*

* Copyright (c) 2008-2009 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:  It is adapter class to handle lbt operations

*

*/

#include <lbtgeocircle.h> 

#include <lbttriggerconditionarea.h> 

#include <lbttriggerfilterbyattribute.h> 

#include <lbtlisttriggeroptions.h>

#include <lbtstartuptrigger.h> 

#include <lbsrequestor.h> 

#include <lbttriggerinfo.h> 

#include <lbttriggerchangeeventnotifier.h>

#include <e32cmn.h>

#include "evtmgmtuilbtadapter.h"

#include "evtdebug.h"

// CONSTANTS

const TInt KUnitConversion = 1000;                        // Unit Converter

_LIT( KTriggerHandlingProcessName, "evthandler.exe" );    // Handler Process Name

_LIT_SECURE_ID( KTriggerHandlingProcessSID,  0x2001E667); // Handler Process UID

_LIT_SECURE_ID( KManagerProcessSID,  0x2001E668);         // Manager Process UID

_LIT( KMyRequestor , "Requestor" );                       //Set requestor information

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

// CEvtMgmtUiLbtAdapter ::CEvtMgmtUiLbtAdapter()

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

//

CEvtMgmtUiLbtAdapter::CEvtMgmtUiLbtAdapter(MEvtMgmtUiLbtObserver&  aObserver)

:CActive( EPriorityStandard ), iObserver(aObserver)

    {   

    }

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

// CEvtMgmtUiLbtAdapter ::ConstructL()

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

//

void CEvtMgmtUiLbtAdapter::ConstructL()

    {   

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::ConstructL()" );

    CActiveScheduler::Add(this);  

    EVTUIDEBUG("scheduler added" );

    // Create a Connection to LBT Sever.

    User::LeaveIfError( iLbtServer.Connect() );

    EVTUIDEBUG("lbtserver connected" );

    // Open 2 Sessions - One for LBT operation and Other for LBT observer 

    User::LeaveIfError( iLbt.Open(iLbtServer) );

    User::LeaveIfError( iLbtObserver.Open(iLbtServer) );

    EVTUIDEBUG("lbt is opened" );

    // Create a Trigger change notifier to listen to any changes to triggers. 

    iEventChangeObserver = CLbtTriggerChangeEventNotifier::NewL( iLbtObserver, *this );

    iEventChangeObserver->Start();

    EVTUIDEBUG("Trigger Change Notifier is started" );

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::ConstructL()" );

    }

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

// CEvtMgmtUiLbtAdapter ::NewL()

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

//

CEvtMgmtUiLbtAdapter* CEvtMgmtUiLbtAdapter::NewL(MEvtMgmtUiLbtObserver&  aObserver)

    {

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::NewL()" );

    CEvtMgmtUiLbtAdapter * self = new (ELeave) CEvtMgmtUiLbtAdapter(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::NewL()" );

    return self;

    }

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

// CEvtMgmtUiLbtAdapter ::~CEvtMgmtUiLbtAdapter()

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

//

CEvtMgmtUiLbtAdapter::~CEvtMgmtUiLbtAdapter()

    {     

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::~CEvtMgmtUiLbtAdapter()" );

    Cancel();

    if(iAttrFilter)

        {

        delete iAttrFilter;

        iAttrFilter = NULL;

        }

    if(iTrigger)

        {

        delete iTrigger;

        iTrigger = NULL;

        }

    delete iEventChangeObserver;

    //Close lbt session and server

    iLbtObserver.Close();

    iLbt.Close();

    iLbtServer.Close();

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::~CEvtMgmtUiLbtAdapter()" );

    }

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

// CEvtMgmtUiLbtAdapter::CreateTrigger

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

//

void CEvtMgmtUiLbtAdapter::CreateTrigger(const TCoordinate& aCenter,

        TReal aRadiusInKiloMeters, const TPtrC& aTriggerName,

        CLbtTriggerEntry::TLbtTriggerState aState )

    {       

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::CreateOrUpdateTrigger()" );

    TRAPD(err, CreateTriggerL( aCenter, aRadiusInKiloMeters, aTriggerName, 

                            aState ) );

    if( err!=KErrNone )

        iObserver.NotifyLbtError(err, iState);

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::CreateOrUpdateTrigger()" );

    }

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

// CEvtMgmtUiLbtAdapter::CreateTriggerL

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

//

void CEvtMgmtUiLbtAdapter::CreateTriggerL(const TCoordinate& aCenter,

        TReal aRadiusInKiloMeters, const TPtrC& aTriggerName,

        CLbtTriggerEntry::TLbtTriggerState aState )

    {        

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::CreateTriggerL()");

    if ( IsActive() )

        {

        User::Leave( KErrInUse );            

        }

    //set state of the machine

    iState = ELbtAdapterCreate;

    EVTUIDEBUG("========== Trigger Parameter Details ===============" );   

    CLbtTriggerConditionArea* cond = GetConditionAreaL(aCenter, aRadiusInKiloMeters);

    CleanupStack::PushL(cond);     

    /*********************** Debug ******************************************/

    TBuf<256> debug;

    debug.Copy( aTriggerName );

    EVTUIDEBUG1("Trigger Name = %S", &debug );

    EVTUIDEBUG1("Event State = %d", aState );

    EVTUIDEBUG1("Radius = %f", aRadiusInKiloMeters*KUnitConversion );

	debug.Copy( KTriggerHandlingProcessName() );

	EVTUIDEBUG1("Trigger handling process name: %S", &debug );

	EVTUIDEBUG1("Trigger handling process SID: %x", KTriggerHandlingProcessSID);

	EVTUIDEBUG1("Manager process SID: %x", KManagerProcessSID);

    /*********************** Debug ******************************************/

    EVTUIDEBUG("========== Trigger Parameter Details end ===============" );   

    if(iTrigger)

       {

       delete iTrigger;

       iTrigger = NULL;

       }

    // Create the Startup trigegr without the command line.

    iTrigger = CLbtStartupTrigger::NewL(          

                            aTriggerName,                           // Trigger name

                            aState,                                 // Trigger state

                            CRequestorBase::ERequestorService,      // Requestor type

                            CRequestorBase::EFormatApplication,     // Requestor format

                            KMyRequestor,                           // Requestor data

                            KManagerProcessSID,                     // Manager Uid

                            cond,                                   // Trigger condition

                            KTriggerHandlingProcessName,            // Trigger handler app

                            KTriggerHandlingProcessSID

                            );          //Trigger state

  	CleanupStack::Pop( cond ); //ownership of cond is transferred.    

    SetActive();

    iStatus = KRequestPending;

    EVTUIDEBUG("Before CreateTrigger" );      

    iLbt.CreateTrigger( *iTrigger, iTriggerId, EFalse, iStatus );            

    EVTUIDEBUG("After CreateTrigger" );      

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::CreateTriggerL()");

    }

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

// CEvtMgmtUiLbtAdapter::GetConditionAreaL

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

//

CLbtTriggerConditionArea* CEvtMgmtUiLbtAdapter::GetConditionAreaL( 

                const TCoordinate& aCenter, TReal aRadiusInKiloMeters )

    {

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::GetConditionAreaL()");

    // Create the Condition Area object depending on the trigger type.

    CLbtTriggerConditionArea* cond = NULL;

    if( Math::IsNaN( aCenter.Latitude() ) || Math::IsNaN( aCenter.Longitude() ) )

        {

        //Define the triggering area   

        CLbtGeoCircle * trigArea = CLbtGeoCircle ::NewLC( TCoordinate(TReal(0), TReal(0), TReal(0) ),1*KUnitConversion );

        //Construct trigger condition

        cond = CLbtTriggerConditionArea::NewL

                    (trigArea,CLbtTriggerConditionArea::EFireOnEnter );

        CleanupStack::Pop( trigArea ); //ownership of trigArea is transferred.

        }

    else

        {

        //Define the triggering area   

        CLbtGeoCircle * trigArea = CLbtGeoCircle ::NewLC( aCenter,aRadiusInKiloMeters*KUnitConversion );

        //Construct trigger condition

        cond = CLbtTriggerConditionArea::NewL

                    (trigArea,CLbtTriggerConditionArea::EFireOnEnter );

        CleanupStack::Pop( trigArea ); //ownership of trigArea is transferred.                

        }

    EVTUIDEBUG1("Lat = %f", aCenter.Latitude() );

    EVTUIDEBUG1("Long = %f", aCenter.Longitude() );

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::GetConditionAreaL()");

    return cond;

    }

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

// CEvtMgmtUiLbtAdapter::UpdateCmdLineArgL

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

//

void CEvtMgmtUiLbtAdapter::UpdateCmdLineArgL( TLbtTriggerId aTriggerId, 

                                                        TEvtEventId aEventId )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::UpdateCmdLineArgL() - %d", aTriggerId );

    //set commandline argument

    const TInt KTriggerIdLength(132); 

    _LIT(KDelimiter, ":");

    TBuf<KTriggerIdLength> cmdArg;

    cmdArg.Zero();

    cmdArg.AppendNumUC(EEvtActionFired);

    cmdArg.Append(KDelimiter());

    cmdArg.AppendNumUC(aEventId);

    CLbtStartupTrigger* trigger = CLbtStartupTrigger::NewLC();

    trigger->SetId( aTriggerId );

    trigger->SetCommandLineL( cmdArg );    

    iState = ELbtAdapterUpdateCmdLineArg;

	EVTUIDEBUG1("Before UpdateTriggerL  - %d", aTriggerId );

    iLbt.UpdateTriggerL( *trigger, CLbtTriggerEntry::EAttributeStartUpCommandLine, ELbtFalse );  

	EVTUIDEBUG1("After UpdateTriggerL  - %d", aTriggerId ); 

    CleanupStack::PopAndDestroy(trigger);

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::UpdateCmdLineArgL() - %d", aTriggerId );

    }

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

// CEvtMgmtUiLbtAdapter::UpdateTriggerL

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

//

void CEvtMgmtUiLbtAdapter::UpdateTriggerL( TLbtTriggerId aTriggerId,

        const TCoordinate& aCenter, TReal aRadiusInKiloMeters,

        CLbtTriggerEntry::TLbtTriggerState aState )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::UpdateTriggerL() - %d", aTriggerId )

    EVTUIDEBUG1("Event State = %d", aState );

    if ( IsActive() )

       {    

       User::Leave( KErrInUse );            

       }

    //Set state of the machine

    iState = ELbtAdapterUpdate;   

    // Create the Condition Area object depending on the trigger type.

    CLbtTriggerConditionArea* cond = GetConditionAreaL(aCenter, aRadiusInKiloMeters );

    CleanupStack::PushL(cond); 

    //create startup trigger object

    if(iTrigger)

       {

       delete iTrigger;

       iTrigger = NULL;

       }

    iTrigger = CLbtStartupTrigger::NewL();

    iTrigger->SetId( aTriggerId );

    iTrigger->SetCondition(cond);    

    CleanupStack::Pop(cond);    //ownership is transferred to trigger.

    iTrigger->SetState(aState);

    // Create the Trigger update attributes mask. 

    TLbtTriggerAttributeFieldsMask fieldsMask;

    fieldsMask = CLbtTriggerEntry::EAttributeState | CLbtTriggerEntry::EAttributeCondition;

    SetActive();

    iStatus = KRequestPending;

    EVTUIDEBUG1("Before UpdateTriggerL  - %d", aTriggerId );

    iLbt.UpdateTrigger( *iTrigger, fieldsMask, ELbtFalse, iStatus);  

    EVTUIDEBUG1("After UpdateTriggerL  - %d", aTriggerId ); 

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::UpdateTriggerL() - %d", aTriggerId );

    }

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

// CEvtMgmtUiLbtAdapter::SetTriggerStateL

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

//

void CEvtMgmtUiLbtAdapter::SetTriggerStateL( TLbtTriggerId  aTriggerId,

									CLbtTriggerEntry::TLbtTriggerState aState )  

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::SetTriggerStateL() - %d", aTriggerId );

    EVTUIDEBUG2("SetTriggerState for Triggerid =%d eventstatus = %d ", aTriggerId, aState);

    //Set state of the machine

    iState = ELbtAdapterSetTriggerState;

    iTriggerId = aTriggerId;

	EVTUIDEBUG1("Before SetTriggerStateL  - %d", aTriggerId );

    iLbt.SetTriggerStateL(aTriggerId, aState, ELbtFalse );

	EVTUIDEBUG1("After SetTriggerStateL  - %d", aTriggerId );

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::SetTriggerStateL() - %d", aTriggerId );

    }

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

// CEvtMgmtUiLbtAdapter::SetTriggersStateL

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

//

void CEvtMgmtUiLbtAdapter::SetTriggersStateL( const RArray<TLbtTriggerId>& aTriggerIdList,

                                    CLbtTriggerEntry::TLbtTriggerState aState )  

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::SetTriggersStateL() Count - %d", aTriggerIdList.Count() );

    if ( IsActive() )

       {    

       User::Leave( KErrInUse );            

       }

    //Set state of the machine

    iState = ELbtAdapterSetTriggersState;  

    if( iAttrFilter )

    	{

    	delete iAttrFilter;

    	iAttrFilter = NULL;

    	}

    // Create an attribute filter to include all the trigger ids

    iAttrFilter = CLbtTriggerFilterByAttribute::NewL();

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

        {

        iAttrFilter->AddTriggerIdL(aTriggerIdList[index]);

        }

    SetActive();

    iStatus = KRequestPending;

    iLbt.SetTriggersState( iStatus, aState, ELbtFalse, iAttrFilter );

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::SetTriggersState()");

    }

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

// CEvtMgmtUiLbtAdapter::DeleteTriggerL

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

//

void CEvtMgmtUiLbtAdapter::DeleteTriggerL( TLbtTriggerId  aTriggerId )  

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::DeleteTriggerL() TriggerID = %d" , aTriggerId);

    EVTUIDEBUG2("SetTriggerState for Triggerid =%d eventstatus = %d ", aTriggerId, iState);

    //set state 

    iState = ELbtAdapterDelete;

    //Set it to member variable so that it can be used in RunL to delete trigger

    iTriggerId = aTriggerId;

	EVTUIDEBUG1("Before DeleteTriggerL  - %d", aTriggerId );

    iLbt.DeleteTriggerL( iTriggerId );

	EVTUIDEBUG1("After DeleteTriggerL  - %d", aTriggerId );

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::DeleteTriggerL() TriggerID = %d" , aTriggerId);

    }

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

// CEvtMgmtUiLbtAdapter::DeleteTriggersL

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

//

void CEvtMgmtUiLbtAdapter::DeleteTriggersL( const RArray<TLbtTriggerId>& aTriggerIdList )  

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::DeleteTriggersL() Count - %d", aTriggerIdList.Count() );

    if ( IsActive() )

        {

        User::Leave( KErrInUse );            

        }

    iState = ELbtAdapterDeleteTriggers;

    SetActive();

    iStatus = KRequestPending;

    iLbt.DeleteTriggers( aTriggerIdList, iStatus );

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::DeleteTriggersL()");

    }

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

// CEvtMgmtUiLbtAdapter::GetTriggerStateL

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

//

CLbtTriggerEntry::TLbtTriggerState CEvtMgmtUiLbtAdapter::GetTriggerStateL( TLbtTriggerId  aTriggerId )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::GetTriggerStateL = %d ", aTriggerId);

    CLbtTriggerEntry::TLbtTriggerState state = CLbtTriggerEntry::EStateDisabled;

	EVTUIDEBUG1("Before GetTriggerLC  - %d", aTriggerId );

    CLbtTriggerInfo * info = iLbt.GetTriggerLC( aTriggerId );

	EVTUIDEBUG1("After GetTriggerLC  - %d", aTriggerId );

    if(info)

        {

        CLbtTriggerEntry* entry = info->TriggerEntry();

        state = entry->State();

        CleanupStack::PopAndDestroy(info);

        }

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::GetTriggerStateL = %d ", aTriggerId);

    return state;

    }

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

// CEvtMgmtUiLbtAdapter::CancelRequest()

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

//

void CEvtMgmtUiLbtAdapter::CancelRequest()

    {     

    EVTUIDEBUG("+ CEvtMgmtUiLbtAdapter::CancelRequest()" );

    Cancel();

    if(iStatus.Int()==KErrCancel)

        {       

		iObserver.NotifyLbtError(KErrCancel, iState);

		}

    EVTUIDEBUG("- CEvtMgmtUiLbtAdapter::CancelRequest()" );

    }

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

// CEvtMgmtUiLbtAdapter::RetrieveLocationL

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

//

void CEvtMgmtUiLbtAdapter::RetrieveLocationL( TLbtTriggerId aTriggerId, TCoordinate& aCenter )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::RetrieveLocationL() TriggerId = %d ", aTriggerId );   

	EVTUIDEBUG1("Before GetTriggerLC  - %d", aTriggerId );

    CLbtTriggerInfo * info = iLbt.GetTriggerLC( aTriggerId );

	EVTUIDEBUG1("After GetTriggerLC  - %d", aTriggerId );

    if(info)

           {

           CLbtTriggerEntry* entry = info->TriggerEntry();

           CLbtTriggerConditionArea* triggArea =  static_cast< CLbtTriggerConditionArea*>( entry->GetCondition());

           CLbtGeoAreaBase* triggGeoArea = static_cast< CLbtGeoAreaBase*>( triggArea->TriggerArea());

           if( triggGeoArea->Type() == CLbtGeoAreaBase::ECircle)

               {

               CLbtGeoCircle* loc = static_cast<CLbtGeoCircle*>( triggArea->TriggerArea() );          

               aCenter = loc->Center();

               EVTUIDEBUG1("GetTriggerLC: Latitude = %f", aCenter.Latitude() );

               EVTUIDEBUG1("GetTriggerLC: Longitude = %f", aCenter.Longitude() );

               }

           else

               {

               User::Leave(KErrNotSupported);

               }

    	   CleanupStack::PopAndDestroy(); //info

           }   

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::RetrieveLocationL() TriggerId = %d ", aTriggerId );  

    }

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

// CEvtMgmtUiLbtAdapter::GetFiredTriggerAccuracyL

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

//

void CEvtMgmtUiLbtAdapter::GetFiredTriggerAccuracyL( TLbtTriggerId aTriggerId, TReal32& aDistance )

    {

    EVTUIDEBUG1("+ CEvtMgmtUiLbtAdapter::GetFiredTriggerAccuracyL() TriggerId = %d ", aTriggerId );   

	EVTUIDEBUG1("Before GetTriggerLC  - %d", aTriggerId );

    CLbtTriggerInfo * info = iLbt.GetTriggerLC( aTriggerId );

	EVTUIDEBUG1("After GetTriggerLC  - %d", aTriggerId );

    if(info)

		{

        CLbtTriggerEntry* entry = info->TriggerEntry();

        CLbtTriggerConditionArea* triggArea =  static_cast< CLbtTriggerConditionArea*>( entry->GetCondition());

        CLbtGeoAreaBase* triggGeoArea = static_cast< CLbtGeoAreaBase*>( triggArea->TriggerArea());

        if( triggGeoArea->Type() == CLbtGeoAreaBase::ECircle)

            {

            TLbtTriggerDynamicInfo* dynInfo = info->DynInfo();

            CLbtGeoCircle* circle = static_cast<CLbtGeoCircle*> (triggGeoArea);

            TCoordinate cord = circle->Center();

            cord.Distance(dynInfo->iFiredLocality, aDistance);

            aDistance = aDistance - circle->Radius();

            aDistance = Abs(aDistance);

            }

        EVTUIDEBUG1( "Fired Trigger Accuracy in Distance = %f", aDistance );

        CleanupStack::PopAndDestroy(); //info

		}   

    EVTUIDEBUG1("- CEvtMgmtUiLbtAdapter::GetFiredTriggerAccuracyL() TriggerId = %d ", aTriggerId );

    }

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

// CEvtMgmtUiLbtAdapter::RunError