/*

* Copyright (c) 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:  LBT Sever Logic

*

*/

// INCLUDE FILES

#include <ecom.h>

#include <e32base.h>

#include <implementationproxy.h>

#include <e32property.h>

#include <lbtstatuspskeys.h>

#include <lbttriggeringsystemsettings.h>

#include <lbterrors.h>

#include "lbtcontainertriggerfilter.h"

#include "lbtserverlogic.h"

#include "lbtserverconsts.h"

#include "lbtcreatetriggeraooperation.h"

#include "lbtstrategybase.h"

#include "lbttriggerfirehandler.h"

#include "lbtbackuprestorelistener.h"

#include "lbtcontainer.h"

#include "lbtglobal.h"

#include "lbtstratergycontainer.h"

#include "lbtlistaooperation.h"

#include "lbtsettingsmanager.h"

#include "lbtcontainertriggerentry.h"

#include "lbttriggermodifyaooperation.h"

#include "lbtnotificationmap.h"

#include "lbttriggerchangeevent.h"

#include "lbtcontainerupdatefilter.h"

#include "lbttriggerfilterbyattribute.h"

#include "lbtlogger.h"

#include "lbtdeletesessiontriggers.h"

#include "lbtappchangehandler.h"

#include "lbtcleanuphandler.h"

#include "lbtsimchangehandler.h"

#include "lbtlogger.h"

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

const TImplementationProxy ImplementationTable[] = 

	{

    IMPLEMENTATION_PROXY_ENTRY( 0x1028312C, CLbtServerLogic::NewL ) 

    };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );

    return ImplementationTable;

    }

TInt OrderTriggerEntryBySid(

    const CLbtContainerTriggerEntry& aLhs, 

    const CLbtContainerTriggerEntry& aRhs)

	{

	CLbtContainerTriggerEntry& lhs = const_cast<CLbtContainerTriggerEntry&>(aLhs);

	CLbtContainerTriggerEntry& rhs = const_cast<CLbtContainerTriggerEntry&>(aRhs);

	if(lhs.ExtendedTriggerInfo()->OwnerSid() < rhs.ExtendedTriggerInfo()->OwnerSid())

		{

		return -1;

		}

	else if(lhs.ExtendedTriggerInfo()->OwnerSid() > rhs.ExtendedTriggerInfo()->OwnerSid())

		{

		return 1;

		}

	else

		{

		return 0;

		}

	}

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

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

// CLbtServerLogic::NewL

// Symbian Two - phase constructor

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

//

CLbtServerLogic* CLbtServerLogic::NewL()

	{

    LBT_TRACE(KLbtLogVerbose|KLbtLogServerLogic,__FILE__, __LINE__, "Entering NewL" );

	CLbtServerLogic* self = new ( ELeave ) CLbtServerLogic;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    LBT_TRACE(KLbtLogVerbose|KLbtLogServerLogic,__FILE__, __LINE__, "Returning from NewL" );

    return self;

	}

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

// CLbtServerLogic::~CLbtServerLogic

// Destructor

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

//

CLbtServerLogic::~CLbtServerLogic()

	{

	FUNC_ENTER("CLbtServerLogic::~CLbtServerLogic");

    // Cancel all outstanding operations.		

	CancelAllOperations();

	delete iBackupRestoreListener;

	delete iStratergyContainer;

	delete iSettingsManager;

	delete iFireHandler;

	delete iAppChangeHandler;

	delete iNotificationMap;

	delete iCleanupHandler;

    delete iSimChangeHandler;	

	iAOOArray.ResetAndDestroy();

	iDeleteSessionTriggersArray.ResetAndDestroy();

	CLbtContainer::Destroy();

	iProperty.Close();

	}

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

// CLbtServerLogic::CLbtServerLogic

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

//

CLbtServerLogic::CLbtServerLogic() : iContainer(NULL)

	{

	}

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

// CLbtServerLogic::ServiceL

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

//

void CLbtServerLogic::ServiceL(const RMessage2 &aMessage, TSubSessionType aType)

	{

	FUNC_ENTER("CLbtServerLogic::ServiceL");

    LBT_TRACE(KLbtLogVerbose|KLbtLogServerLogic,__FILE__, __LINE__, "Received IPC function = %d client = %x", aMessage.Function(), aMessage.SecureId().iId );

	// If backup or restore operation is in progress then return server busy

	if(iBackupRestoreListener->IsBackupRestoreOperationInProgress())

		{

		LbtGlobal::RequestComplete(aMessage, KErrServerBusy);

		return;

		}	

	/**

	 * All IPC messages which requires notification will be 

	 * stored and serviced by server logic. Other messages will

	 * be serviced by AOOperation objects

	 */ 

	switch(aMessage.Function())

		{

		/**

		 * The below are all notification requests. Hence insert the 

		 * message into the message array and notify the requestor  

		 * when the event occurs	

		 */

		case ELbtNotifyTriggerChangeEvent:

		case ELbtNotifyTriggerFired:

		case ELbtNotifyNearestTriggerChange:

		case ELbtNotifyTriggeringSysSettingChange:

		case ELbtNotifyTriggeringSysStatusChange:

			{

			TInt retValue=ValidateChangeNotification(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

			InsertIntoNotificationMapL(aMessage, aType);			

			break;

			}

		case ELbtCnclNotifyTriggerChangeEvent:		

			{

			TInt retVal = RemoveFromNotificationMap(aMessage, ELbtNotifyTriggerChangeEvent);

			LbtGlobal::RequestComplete(aMessage, retVal);

			break;

			}

		case ELbtCnclNotifyTriggerFired:

			{

			TInt retVal = RemoveFromNotificationMap(aMessage, ELbtNotifyTriggerFired);

			LbtGlobal::RequestComplete(aMessage, retVal);			

			break;

			}

		case ELbtCnclNotifyNearestTriggerChange:

			{

			TInt retVal = RemoveFromNotificationMap(aMessage, ELbtNotifyNearestTriggerChange);

			LbtGlobal::RequestComplete(aMessage, retVal);			

			break;

			}

		case ELbtCnclNotifyTriggeringSysStatusChange:

			{

			TInt retVal = RemoveFromNotificationMap(aMessage, ELbtNotifyTriggeringSysStatusChange);

			LbtGlobal::RequestComplete(aMessage, retVal);			

			break;

			}

		case ELbtCnclNotifyTriggeringSysSettingChange:

			{

			TInt retVal = RemoveFromNotificationMap(aMessage, ELbtNotifyTriggeringSysSettingChange);

			LbtGlobal::RequestComplete(aMessage, retVal);			

			break;

			}

		case ELbtCreateTrigger: // create trigger

			{

			// Validate the IPC message and the trigger for create trigger

			TInt retVal = ValidateCreateTriggerMessage(aMessage);

			if( retVal != KErrNone )

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retVal);				

				break;

				}

			// If capability check is successful then create the aooperation object

			CLbtCreateTriggerAOOperation* operation = 

						CLbtCreateTriggerAOOperation::NewL(*this, 

														   aMessage, 

														   *iContainer, 

														   aType,

														   *iSettingsManager);

			operation->StartOperationL();

			break;

			}

		case ELbtGetTriggers:

		case ELbtGetFiredTriggers:

		case ELbtListTriggerIds:

			{

			TInt retValue=ValidateGeneralOperation(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

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

				{

				CLbtAOOperationBase* operation = iAOOArray[i];				

				if(operation->GetSecureId() == aMessage.SecureId() &&

				   operation->GetSubSessionHandle() == aMessage.Int3() &&

				   ( iAOOArray[i]->GetFunction() == ELbtGetTriggersBufferSize ||

    			     iAOOArray[i]->GetFunction() == EGetFiredTriggersCount ||

    			     iAOOArray[i]->GetFunction() == ELbtGetListTriggerIdsSize ) )

					{

					// The session id and the client of the message are the 

					// same and since a sub-session can have just one outstanding

					// asynchronous service request, the AO object obtained must be

					// the listAO operation object to service this request

					CLbtListAOOperation* listOperation = static_cast<CLbtListAOOperation*>(operation);

					listOperation->ServiceMessageL(aMessage);

					break;

					}

				}

			break;

			}

		case ELbtGetTriggersBufferSize:

		case EGetFiredTriggersCount:

		case ELbtGetListTriggerIdsSize:

			{

			TInt retValue=ValidateGeneralOperation(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

			CLbtListAOOperation* operation = 

						CLbtListAOOperation::NewL(*this, aMessage, *iContainer, aType);

			operation->StartOperationL();

			break;

			}

		case ELbtUpdateTrigger:

		case ELbtSetTriggerState:

		case ELbtSetTriggersState:

		case ELbtDeleteTrigger:

		case ELbtDeleteTriggers:

			{

			TInt retValue=ValidateGeneralOperation(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

			CLbtTriggerModifyAOOperation* operation = 

						CLbtTriggerModifyAOOperation::NewL(*this, aMessage, *iContainer, aType,*iSettingsManager);

			operation->StartOperationL();

			break;

			}

		case ELbtGetTriggeringSysSetting:

			{

			TInt retValue=ValidateGetTriggeringSysSetting(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

			TInt retVal = GetTriggeringSystemSettings( aMessage, aType );

			if(retVal == KErrNone)

				{

				LbtGlobal::RequestComplete(aMessage, KErrNone);

				}

			break;

			}

		case ELbtSetTriggeringSettings:

			{

			TInt retValue=ValidateSetTriggeringSetting(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

        	// The request can only be through the LT management API.

        	if ( TLbtManagementLibrary != aType ) 

			    {

			    // This is not a management library. Hence return access denied.

    		    aMessage.Complete( KErrAccessDenied );

			    }

            else

                {

        	    TLbtTriggeringSystemManagementSettings settings;

        		TPckg<TLbtTriggeringSystemManagementSettings> pckgSettings(settings);

                // In case of error in LbtGlobal::Read then the client is already

                // panic'ed hence there is no need to complete the message again.

    			if( !LbtGlobal::Read(aMessage, KParamSettings, pckgSettings) )

    				{

                    // KParamMask slot contains the mask of the settings to be changed.

                    SetTriggeringSystemSettings( settings, aMessage.Int0() );

        		    aMessage.Complete( KErrNone );

    				}

                }

			// TODO: Handle triggering settings change request from management library

			//HandleNotificationOperationsL(aMessage);

			break;

			}

		case ELbtGetTriggeringSysStatus:

	        {

	        TInt retValue=ValidateGetTriggeringSysStatus(aMessage);

			if(retValue!=KErrNone)

				{

				// If validation failed then complete the request with the appropriate error code

				LbtGlobal::RequestComplete(aMessage, retValue);				

				break;

				}

			if ( TLbtManagementLibrary != aType ) 

			    {

			    // This is not a management library. Hence return access denied.

    		    aMessage.Complete( KErrAccessDenied );

			    }

		    TLbtTriggeringSystemStatus systemStatus;

		    GetTriggeringSysStatus( systemStatus );

		    TPckg<TLbtTriggeringSystemStatus> systemStatusPckg( systemStatus );

		    TInt error = LbtGlobal::Write(aMessage, KParamStatus, systemStatusPckg); 

		    LbtGlobal::RequestComplete(aMessage, error);

            break;

	        }

	    case ELbtCancelCreateTrigger:

	    	{

	    	if(!iAOOArray.Count())

	    		{

	    		LbtGlobal::RequestComplete(aMessage,KErrNotFound);	

	    		break;

	    		}

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

	    		{

	    		if((iAOOArray[i]->GetSecureId()==aMessage.SecureId()) &&

	    			(iAOOArray[i]->GetFunction()==ELbtCreateTrigger) &&

	    			(iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()))

	    			{

	    			CLbtCreateTriggerAOOperation* createTriggerAOOperation=

	    							static_cast<CLbtCreateTriggerAOOperation*>

	    							(iAOOArray[i]);

	    			createTriggerAOOperation->CancelCreateTrigger();	

	    			LbtGlobal::RequestComplete(aMessage,KErrNone);

	    			return;	

	    			}

	    		}

	    	LbtGlobal::RequestComplete(aMessage,KErrNotFound);

			break;	    

	    	}

		case ELbtCancelDeleteTriggers:

		    {

		    if(!iAOOArray.Count())

                {

                LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

                break;

                }

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

                {

                if((iAOOArray[i]->GetSecureId()==aMessage.SecureId())&& 

                    (iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()) &&

                    (iAOOArray[i]->GetFunction()==ELbtDeleteTriggers))

                    {

                    CLbtTriggerModifyAOOperation* triggerModifyAOOperation=

                                    static_cast<CLbtTriggerModifyAOOperation*>

                                    (iAOOArray[i]);

                    triggerModifyAOOperation->CancelModifyOperation();  

                    LbtGlobal::RequestComplete(aMessage,KErrNone); 

                    return;

                    }

                }

            LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

            break;      

            }

		case ELbtCancelSetTriggersState:

		    {

		    if(!iAOOArray.Count())

                {

                LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

                break;

                }

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

                {

                if((iAOOArray[i]->GetSecureId()==aMessage.SecureId())&& 

                    (iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()) &&

                    (iAOOArray[i]->GetFunction()==ELbtSetTriggersState))

                    {

                    CLbtTriggerModifyAOOperation* triggerModifyAOOperation=

                                    static_cast<CLbtTriggerModifyAOOperation*>

                                    (iAOOArray[i]);

                    triggerModifyAOOperation->CancelModifyOperation();  

                    LbtGlobal::RequestComplete(aMessage,KErrNone); 

                    return;

                    }

                }

            LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

            break;      

            }

		case ELbtCancelUpdateTrigger:    

	    	{

	    	if(!iAOOArray.Count())

	    		{

	    		LbtGlobal::RequestComplete(aMessage,KErrNotFound);	

	    		break;

	    		}

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

	    		{

	    		if((iAOOArray[i]->GetSecureId()==aMessage.SecureId())&& 

	    		    (iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()) &&

	    			(iAOOArray[i]->GetFunction()==ELbtUpdateTrigger ))

	    			{

	    			CLbtTriggerModifyAOOperation* triggerModifyAOOperation=

	    							static_cast<CLbtTriggerModifyAOOperation*>

	    							(iAOOArray[i]);

	    			triggerModifyAOOperation->CancelModifyOperation();	

                    LbtGlobal::RequestComplete(aMessage,KErrNone); 

                    return;

	    			}

	    		}

	    	LbtGlobal::RequestComplete(aMessage,KErrNotFound);	

			break;	 	

	    	} 

		case ELbtCancelListTriggerIds:

		    {

		    if(!iAOOArray.Count())

                {

                LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

                break;

                }

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

                {

                if((iAOOArray[i]->GetSecureId()==aMessage.SecureId()) &&

                    (iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()) &&

                    (iAOOArray[i]->GetFunction()==ELbtGetListTriggerIdsSize))

                    {

                    CLbtListAOOperation* listAOOperation=

                                    static_cast<CLbtListAOOperation*>

                                    (iAOOArray[i]);

                    listAOOperation->CancelListOperation(); 

                    LbtGlobal::RequestComplete(aMessage,KErrNone); 

                    return;

                    }

                }

            LbtGlobal::RequestComplete(aMessage,KErrNotFound);  

            break;   

            }

		case ELbtCancelGetTriggers:

	    	{

	    	if(!iAOOArray.Count())

	    		{

	    		LbtGlobal::RequestComplete(aMessage,KErrNotFound);	

	    		break;

	    		}

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

	    		{

	    		if((iAOOArray[i]->GetSecureId()==aMessage.SecureId()) &&

	    			(iAOOArray[i]->GetSubSessionHandle()==aMessage.Int3()) &&

	    			(iAOOArray[i]->GetFunction()==ELbtGetTriggersBufferSize))