/*

* Copyright (c) 2002-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:  Client-Server communication

*

*/

#include <e32std.h>

#include <s32strm.h>

#include <s32mem.h>

#include "lbt.h"

#include "lbtserver.h"

#include "lbttriggerinfo.h"

#include "lbterrors.h"

#include "lbtserverconsts.h"

#include "lbtsessiontrigger.h"

#include "lbtstartuptrigger.h"

#include "lbtclientrequester.h"

#include "lbtlisttriggeroptions.h"

#include "lbttriggerfilterbase.h"

#include "lbttriggerinfo.h"

#include "lbttriggerfilterbyattribute.h"

#include "lbttriggerconditionarea.h"

#include "lbtserverconsts.h"

#include "lbttriggeringsystemmanagementsettings.h"

#include "lbttriggerfilterbyarea.h"

#include "lbtgeocircle.h"

#include "lbtgeocell.h"

#include "lbtgeohybrid.h"

#include "lbtterminalptrholder.h"

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

// RLbt::RLbt()

//

// Default constructor.

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

// 

EXPORT_C RLbt::RLbt()

    { // Handling of these functions need to be discussed.

	TRAP_IGNORE(iPtrHolder = CLbtSubSessnPtrHolder::NewL(10, 10));

	TRAP_IGNORE(iClientRequester=CLbtClientRequester::NewL( *this ));

	TRAP_IGNORE(iTriggerCreationInfo=new( ELeave)TLbtTriggerCreationInfo);

	TRAP_IGNORE(iTriggerStateInfo = new( ELeave ) TLbtTriggerStateInfo);

	TRAP_IGNORE(iTriggerUpdationInfo = new( ELeave ) TLbtTriggerUpdationInfo);

	}

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

// RLbt::~RLbt

//

// Destructor.

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

// 	

EXPORT_C RLbt::~RLbt()

    {

    if(iPtrHolder)

        {

        delete iPtrHolder;

        iPtrHolder = NULL;

				}

    if(iClientRequester)

        {

        delete iClientRequester;

        iClientRequester = NULL;

        }

    if(iTriggerCreationInfo)    

    	{

    	delete iTriggerCreationInfo; 

     	iTriggerCreationInfo=NULL; 

    	} 

    if( iTriggerUpdationInfo )

        {

        delete iTriggerUpdationInfo;

        iTriggerUpdationInfo = NULL;

        }

    if( iTriggerStateInfo )

        {

        delete iTriggerStateInfo;

        iTriggerStateInfo = NULL;

        }

    iTriggerList.Close();	

    }

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

// RLbt::ConstructL

//Symbian 2nd phase constructor can leave.

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

//     

void RLbt::ConstructL()

    {

    iCreateIteratorFlag=EFalse;

    }

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

// RLbt::Open

//

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

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

//

EXPORT_C TInt RLbt::Open( RLbtServer& aServer )

    {

    __ASSERT_ALWAYS(aServer.Handle() != 0,

		User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	__ASSERT_ALWAYS(! SubSessionHandle() , User::Panic  (KLbtClientPanicCategory, ELbtServerBadHandle));

	TRAPD(ret, ConstructL());

	if (ret == KErrNone)

		{

		ret = CreateSubSession(aServer, ELbtSubSessionOpen, TIpcArgs());

		}

	return ret;     

    }

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

// RLbt::Open

//

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

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

//

EXPORT_C TInt RLbt::Open()

    {

    return 0;	

    }   

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

// RLbt::Close

//

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

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

//

EXPORT_C void RLbt:: Close()

    {

    TBool isActive = iClientRequester-> IsActive();

    TInt status = iClientRequester->iStatus.Int();

	if(SubSessionHandle())

	    {

    	CloseSubSession(ELbtSubSessionClose);

	    }

	if( isActive && status == KRequestPending )

	    {

	    User::Panic(KLbtClientPanicCategory, ELbtRequestsNotCancelled );

	    }

    }

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

// RLbt::CreateTrigger

//

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

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

//

EXPORT_C void RLbt:: CreateTrigger( 

            const CLbtTriggerEntry& aTrigger,

            TLbtTriggerId& aTriggerId,

            TBool aFireOnCreation,

            TRequestStatus& aStatus )

    {

    TRAPD( error, CreateTriggerL( aTrigger,aTriggerId,aFireOnCreation,aStatus ));

    if( KErrNone != error )

    	{

    	TRequestStatus* status = &aStatus;

    	User::RequestComplete(status,error);

    	}

    }

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

// RLbt::CreateTriggerL

//

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

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

//

void RLbt:: CreateTriggerL( 

            const CLbtTriggerEntry& aTrigger,

            TLbtTriggerId& aTriggerId,

            TBool aFireOnCreation,

            TRequestStatus& aStatus )

    {

	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

    aStatus=KRequestPending;

	TRequestStatus* status=&aStatus;

	if(iClientRequester->IsActive())

		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

	if(aTrigger.GetCondition()==NULL || 

	   aTrigger.Name()==KNullDesC)

	    {

	    User::RequestComplete(status,KErrArgument);

	    return;

	    }

	RRequestorStack requestors;

	aTrigger.GetRequestorsL( requestors );

	TInt count = requestors.Count();

	requestors.ResetAndDestroy();

	if( !count )

	    {

	    User::Leave( KErrAccessDenied );

	    }

	if(aTrigger.Type()==CLbtTriggerEntry::ETypeStartup)

		{

		TBuf<256> fileName;

    	TSecureId secureId;

    	const CLbtStartupTrigger* trigger=static_cast<const CLbtStartupTrigger*>

    							(&aTrigger);

    	trigger->GetProcessId(fileName,secureId);

    	if(fileName.Length()==0)

    		{

			User::RequestComplete(status,KErrArgument);

	    	return;    		

    		}

		}

    const CLbtTriggerConditionArea* cond =static_cast<const CLbtTriggerConditionArea*>( aTrigger.GetCondition()	);

     CLbtGeoAreaBase* area = cond->TriggerArea();

	if(!area)

	    {

	    if(aStatus.Int()== KRequestPending)

	        {

	        User::RequestComplete(status,KErrArgument);

	        }

	    return;    

	    }

	ValidateGeoAreaInformationL( area );

	if( area->Type() == CLbtGeoAreaBase::ECellular || area->Type() == CLbtGeoAreaBase::EHybrid )

        {        

        // In the current version of LBT, we dont support EXIT type cell/WLAN based triggers

        if( cond->Direction() == CLbtTriggerConditionArea::EFireOnExit )

            {

            User::RequestComplete( status,KErrNotSupported );

            return;

            }

        }

	TIpcArgs args;

	CBufFlat* buffer=NULL;

	RBufWriteStream writeStream;

	buffer = CBufFlat::NewL(512);

	CleanupStack::PushL(buffer);

	writeStream.Open(*buffer);

	CleanupClosePushL(writeStream);

	writeStream << aTrigger;

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	TPtr8 ptr = buffer->Ptr(0);

	iPtrHolder->Ptr(0).Set(

		reinterpret_cast<TUint8*>(&aTriggerId),

		sizeof(aTriggerId),sizeof(aTriggerId));

	iPtrHolder->Ptr(1).Set(ptr);	

	iTriggerCreationInfo->iFireOnCreation=aFireOnCreation;

	iTriggerCreationInfo->iTriggerType=aTrigger.Type();

	iPtrHolder->Ptr(2).Set(reinterpret_cast<TUint8*>(iTriggerCreationInfo),

	sizeof(TLbtTriggerCreationInfo),sizeof(TLbtTriggerCreationInfo));	

	iClientRequester->SetStatus(aStatus);

	iClientRequester->SetBuffer(buffer);

	CleanupStack::Pop(buffer);

	args.Set(0,&iPtrHolder->Ptr(0));

	args.Set(1,&iPtrHolder->Ptr(1));

	args.Set(2,&iPtrHolder->Ptr(2));

	SendReceive(ELbtCreateTrigger, args, iClientRequester->iStatus );

	iClientRequester->Start();

	}

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

// RLbt::CancelCreateTrigger

//

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

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

//

EXPORT_C void RLbt::CancelCreateTrigger()

    {

	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	TInt error = SendReceive(ELbtCancelCreateTrigger);

	if( error == KErrNone )

	    {

	    iClientRequester->Cancel();

	    }

    }

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

// RLbt::DeleteTriggerL

//

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

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

//

 EXPORT_C void RLbt::DeleteTriggerL( TLbtTriggerId aId )

    {

    __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	TIpcArgs args;

	TPckg<TLbtTriggerId> triggerId(aId);	

	args.Set(0, &triggerId);

	User::LeaveIfError(SendReceive(ELbtDeleteTrigger, args));

    }

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

// RLbt::DeleteTriggerL

//

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

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

//

 EXPORT_C void RLbt::DeleteTriggersL( CLbtTriggerFilterBase* aFilter )

    {

	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	TIpcArgs args;

	CBufFlat* buffer = CBufFlat::NewL(512);	

	CleanupStack::PushL(buffer);

	RBufWriteStream writeStream;

	writeStream.Open(*buffer);

	CleanupClosePushL(writeStream);

	CLbtTriggerFilterBase::TFilterType type;

	if(aFilter == NULL)

	    {

	    CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

	    CleanupStack::PushL(filter);

		filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

        filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

        writeStream<< *filter;

        type=filter->Type();

        CleanupStack::PopAndDestroy(filter);

	    }

	else

        {   

        if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

            {

            CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

            ValidateGeoAreaInformationL( areaFilter->Area() );

            }

    	writeStream << *aFilter;

    	type=aFilter->Type();

        }	 

	writeStream.CommitL();

	TPtr8 ptr = buffer->Ptr(0);

	args.Set(KParamFilterType,type);

	args.Set(KParamFilter,&ptr);

	User::LeaveIfError( SendReceive(ELbtDeleteTriggers, args) );

    CleanupStack::PopAndDestroy(&writeStream);

    CleanupStack::PopAndDestroy(buffer);	

    }

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

// RLbt::DeleteTriggers

//

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

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

//

EXPORT_C void RLbt::DeleteTriggers( TRequestStatus& aStatus,

                        CLbtTriggerFilterBase* aFilter )

    {

    TRAPD( error,DeleteTriggersL( aFilter,aStatus ) );

    if( KErrNone != error )

    	{

    	TRequestStatus* status=&aStatus;

    	User::RequestComplete(status,error);

    	}

    }

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

// RLbt::DeleteTriggersL

//

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

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

//

void RLbt::DeleteTriggersL( 

            CLbtTriggerFilterBase* aFilter,

            TRequestStatus& aStatus )

    {

    __ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	aStatus = KRequestPending;

	if(iClientRequester->IsActive())

		User::Panic(KLbtClientPanicCategory, ELbtDuplicateRequest);

	TIpcArgs args;

	CBufFlat* buffer=NULL;

	RBufWriteStream writeStream;

        buffer = CBufFlat::NewL(512);

	    CleanupStack::PushL(buffer);

	    writeStream.Open(*buffer);

	    CleanupClosePushL(writeStream);

	    CLbtTriggerFilterBase::TFilterType type;

	if(aFilter == NULL)

        {

        CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

        CleanupStack::PushL(filter);

    	filter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);

        filter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);

        writeStream<< *filter;

        type=filter->Type();

        CleanupStack::PopAndDestroy(filter);

        }

	else

        {  

        if( aFilter->Type() == CLbtTriggerFilterBase::EFilterByArea )

            {

            CLbtTriggerFilterByArea* areaFilter = static_cast<CLbtTriggerFilterByArea*> ( aFilter );

            ValidateGeoAreaInformationL( areaFilter->Area() );

            }

    	writeStream << *aFilter;

    	type=aFilter->Type();

        }	 

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

    TPtr8 ptr = buffer->Ptr(0);

	iPtrHolder->Ptr(0).Set(ptr);

	args.Set(KParamFilterType,type);

	args.Set(KParamFilter,&iPtrHolder->Ptr(0));

	iClientRequester->SetStatus(aStatus);

	iClientRequester->SetBuffer(buffer);

	CleanupStack::Pop(buffer);

	SendReceive(ELbtDeleteTriggers, args,iClientRequester->iStatus);

	iClientRequester->Start();

    }

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

// RLbt::DeleteTriggersL

//

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

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

//

EXPORT_C void RLbt::DeleteTriggersL( 

            const RArray<TLbtTriggerId> &aTriggerIdList )

    {

	__ASSERT_ALWAYS(SubSessionHandle(), User::Panic(KLbtClientPanicCategory, ELbtServerBadHandle));

	if(aTriggerIdList.Count()<1)

	    {

	    return;

	    }

	TIpcArgs args;

	TInt i=0;

	CBufFlat* buffer = CBufFlat::NewL(512);	

	CleanupStack::PushL(buffer);

	RBufWriteStream writeStream;

	writeStream.Open(*buffer);

	CleanupClosePushL(writeStream);

	TInt listCount=aTriggerIdList.Count();

	CLbtTriggerFilterByAttribute* filter = CLbtTriggerFilterByAttribute::NewL();

	CleanupStack::PushL(filter);

	while(i<listCount)

	    {

        filter->AddTriggerIdL(aTriggerIdList[i]);

        i++;

	    }

	writeStream<<*filter;

	writeStream.CommitL();

	TPtr8 ptr = buffer->Ptr(0);

	args.Set(KParamFilterType,filter->Type());

	CleanupStack::PopAndDestroy(filter);

	CleanupStack::PopAndDestroy(&writeStream);

	args.Set(KParamFilter,&ptr);

	CleanupStack::Pop(buffer);

	User::LeaveIfError(SendReceive(ELbtDeleteTriggers,args));	

	delete buffer;

    }

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

// RLbt::DeleteTriggers

//

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

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

//

EXPORT_C void RLbt::DeleteTriggers( 

            const RArray<TLbtTriggerId>& aTriggerIdList,

            TRequestStatus& aStatus )

    {

    TRAPD( error,DeleteTriggersL( aTriggerIdList,aStatus ));

    if( KErrNone != error )

    	{

    	TRequestStatus* status=&aStatus;

    	User::RequestComplete( status,error );

    	}

    }

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

// RLbt::DeleteTriggersL

//

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