/*

* Copyright (c) 2006 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:  This file defines the app removal handler

*

*/

// INCLUDE FILES

#include <apgcli.h>

#include <apaid.h>

#include <apgnotif.h>

#include <driveinfo.h>

#include "lbttriggerfilterbyattribute.h"

#include "lbtappchangehandler.h"

#include "lbtcontainertriggerfilter.h"

#include "lbtcontainerupdatefilter.h"

#include "lbtcontainer.h"

#include "lbtcleanuphandler.h"

#include "lbtserverlogictriggerchangeobserver.h"

#include "lbtlogger.h"

// CONSTANTS

_LIT(KMMCErrorChar, "<"); //if MMC card char retrieval failed, it is assigned.

_LIT(KCharColon, ":"); 

// LOCAL ENUMS

enum

	{

	EOpNone,

	EOpRegiseteredForInitialListPoplulation,

	EOpRegiseteredForListPoplulation,

	EOpRemovalTriggerDeletion,

	EOpDeletionStartupProcessTriggers,

	EOpRemovalListingStartupProcessTriggers,

	EOpRemovalDeletingStartupProcessTriggers,

	EOpRemovalTriggerInvalidation,

	EOpMMCRemovalListingTriggers,

	EOpMMCRemovalListingTriggerForStartupProcess,

	EOpMMCInsertionListingTriggers,

	EOpMMCInsertionListingTriggerForStartupProcess,

	EOpRequestValidityChange	

	};

// LOCAL STRUCTURES

struct TLbtAppInfo

	{

	TFileName iFullName;

	TUid iUid;

	};

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

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

// CLbtAppRemovalHandler::NewL

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

//

CLbtAppChangeHandler* CLbtAppChangeHandler::NewL(CLbtContainer& aContainer, CLbtCleanupHandler& aCleanupHandler,

                                                 MLbtServerLogicTriggerChangeObserver& aTriggerChangeObserver)

	{

	FUNC_ENTER("CLbtAppChangeHandler::NewL");

	CLbtAppChangeHandler* self = new (ELeave) CLbtAppChangeHandler(aContainer,aCleanupHandler,

	                                                               aTriggerChangeObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

	CleanupStack::Pop( self );  

	return self;

	}

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

// CLbtAppChangeHandler::ConstructL

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

//

void CLbtAppChangeHandler::ConstructL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::ConstructL");

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

	MemoryCardChar();

	}

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

// CLbtAppChangeHandler::StartListeningL

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

//

void CLbtAppChangeHandler::StartListeningL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::StartListeningL");

	if(!iAppListNotifier)

		{

		iAppListNotifier = CApaAppListNotifier::NewL(this, CActive::EPriorityStandard);

		iAppArcSession.RegisterListPopulationCompleteObserver(iStatus);

		iOperation = EOpRegiseteredForInitialListPoplulation;

		SetActive();

		}

	}

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

// CLbtAppChangeHandler::FindElementInArray

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

//

TInt CLbtAppChangeHandler::FindElementInArray(RArray<TLbtAppInfo>& aArray, TLbtAppInfo& aElement)

	{

	FUNC_ENTER("CLbtAppChangeHandler::FindElementInArray");

	// Parse the array to find out if the element is present

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

		{

		if(aArray[i].iUid == aElement.iUid)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CLbtAppChangeHandler::HandleAppListRemovalEvent

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

//

void CLbtAppChangeHandler::HandleAppListRemovalEvent(RArray<TLbtAppInfo>& aNewAppList)

	{

	FUNC_ENTER("CLbtAppChangeHandler::HandleAppListRemovalEvent");

	RArray<TUid> appRemovalList;

	TBool appsInMMC = EFalse;

	/// Check which apps is un-installed/removed

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

		{

		TInt index = FindElementInArray(aNewAppList, iCurrentInstalledApps[i]);

		if(KErrNotFound == index)

			{

			// This application has be uninstalled/removed

			TLbtAppInfo appInfo = iCurrentInstalledApps[i];

			// The removed application resided in the MMC card

			// Check if the application resides in MMC

			if( appInfo.iFullName.FindC(iMMCDriveChar) >= 0 )

				{

				appsInMMC = ETrue;				

				}

			}

		}

	if( iAppList.Count() == 0 )

		{

		iAppList.Reset();

		LOG("No application found removed");

		return;

		}

	TInt error = KErrNone;

	if( appsInMMC )

		{

		TRAP(error, HandleMMCApplicationRemovalL() );

		}

	else

		{

		TRAP(error, HandleApplicationUninstallationL());

		}

	if( error != KErrNone )

		{

		iOperation = EOpNone;

		}

	}

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

// CLbtAppChangeHandler::HandleAppListAdditionEvent

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

//

void CLbtAppChangeHandler::HandleAppListAdditionEvent(RArray<TLbtAppInfo>& aNewAppList)

	{

	FUNC_ENTER("CLbtAppChangeHandler::HandleAppListAdditionEvent");

	// Check which all app(s) have been added back

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

		{

		TInt index = FindElementInArray(iCurrentInstalledApps, aNewAppList[i]);		

		if(KErrNotFound == index)

			{

			// This application has been added

			TLbtAppInfo appInfo = aNewAppList[i];

			if( appInfo.iFullName.FindC( iMMCDriveChar ) >= 0 )

				{				

				// Append to the array only if the application resides on the MMC

				}

			}

		}

	if(iAppList.Count() > 0)

		{

		TRAPD(error, SetValidTriggersOfApplicationsL());

		if(error != KErrNone)

			{

			ERROR("SetValidTriggersOfApplicationsL error = %d", error);

			iAppList.Close();

			iOperation = EOpNone;

			}

		}

	}

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

// CLbtAppChangeHandler::SetValidTriggersOfApplicationsL

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

//

void CLbtAppChangeHandler::SetValidTriggersOfApplicationsL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::SetValidTriggersOfApplicationsL");

	// First do a list triggers to get the list of triggers owned by that application

	iOperation = EOpMMCInsertionListingTriggers;

	CLbtListTriggerOptions* listOptions = CLbtListTriggerOptions::NewL();

	CleanupStack::PushL(listOptions);

	CLbtTriggerFilterByAttribute* attributeFilter = 

	                                CLbtTriggerFilterByAttribute::NewL();

	CleanupStack::PushL(attributeFilter);

	attributeFilter->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

	listOptions->SetFilter(attributeFilter);

	// Retreive only the trigger id of the trigger

	TLbtTriggerAttributeFieldsMask mask = CLbtTriggerEntry::EAttributeId;

	listOptions->SetRetrievedFields(mask, 0);

	CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL();

	CleanupStack::PushL(containerFilter);

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

		{

		containerFilter->AddOwnerSidInFilterL(iAppList[i].iUid); 

		}

	CLbtContainerListOptions* containerListOptions = CLbtContainerListOptions::NewL(listOptions, containerFilter);

	CleanupStack::PushL(containerListOptions);

	CleanupStack::Pop(4); // containerListOptions, containerFilter, attributeFilter & listOptions

	iContainer.ListTriggers(containerListOptions, iTriggerEntries, iOpId, iStatus);

	SetActive();

	}

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

// CLbtAppChangeHandler::HandleAppListEvent

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

//

void CLbtAppChangeHandler::HandleAppListEvent(TInt /*aEvent*/)

	{

	FUNC_ENTER("CLbtAppChangeHandler::HandleAppListEvent");

	if( iOperation == EOpNone && !IsActive() )

		{

		iOperation = EOpRegiseteredForListPoplulation;

		iAppArcSession.RegisterListPopulationCompleteObserver(iStatus);

		SetActive();

		return;

		}

	iOperation = EOpNone;

	RArray<TLbtAppInfo> newAppList;

	// First get the set of installed applications in the system

	iAppArcSession.GetAllApps();

	TApaAppInfo appInfo;

	TInt error = iAppArcSession.GetNextApp(appInfo);

	while(KErrNone == error)

		{

		TLbtAppInfo lbtAppInfo;

        lbtAppInfo.iUid = appInfo.iUid;

        lbtAppInfo.iFullName.Zero();

        lbtAppInfo.iFullName.Copy( appInfo.iFullName );

		TRAPD(err, newAppList.AppendL(lbtAppInfo));

		if(err != KErrNone)

			{

			break;

			}

		error = iAppArcSession.GetNextApp(appInfo);

		}

	LOG1("newAppList.Count():%d",newAppList.Count());

	LOG1("iCurrentInstalledApps.Count():%d",iCurrentInstalledApps.Count());

	if(newAppList.Count() > iCurrentInstalledApps.Count())

		{

		HandleAppListAdditionEvent(newAppList);

		}

	else

		{

		LOG("newAppList.Count() < iCurrentInstalledApps.Count()");

		HandleAppListRemovalEvent(newAppList);

		}

	iCurrentInstalledApps.Reset();

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

	    {

	    }

	newAppList.Close();

	}

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

// CLbtAppChangeHandler::StopListening

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

//

void CLbtAppChangeHandler::StopListening()

	{

	FUNC_ENTER("CLbtAppChangeHandler::StopListening");

	delete iAppListNotifier;

	iAppListNotifier = NULL;

	iCurrentInstalledApps.Close();

	}

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

// CLbtAppChangeHandler::HandleMMCApplicationRemovalL

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

//

void CLbtAppChangeHandler::HandleMMCApplicationRemovalL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::HandleMMCApplicationRemovalL");

	if( IsMemoryCardPresent() )

		{

		// If memory card is present it means to say that the application

		// has been un-installed

		HandleApplicationUninstallationL( );

		}

	else 

		{

		// MMC card has been removed. Hence invalidate all the triggers that 

		// belong to the application.

		// First do a list triggers to get the list of triggers owned by that application

		iOperation = EOpMMCRemovalListingTriggers;

		CLbtListTriggerOptions* listOptions = CLbtListTriggerOptions::NewL();

		CleanupStack::PushL(listOptions);

		CLbtTriggerFilterByAttribute* attributeFilter = 

		                                CLbtTriggerFilterByAttribute::NewL();

		CleanupStack::PushL(attributeFilter);

		attributeFilter->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

		listOptions->SetFilter(attributeFilter);

		// Retreive only the trigger id of the trigger

		TLbtTriggerAttributeFieldsMask mask = CLbtTriggerEntry::EAttributeId;

		listOptions->SetRetrievedFields(mask, 0);

		CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL();

		CleanupStack::PushL(containerFilter);

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

			{

			containerFilter->AddOwnerSidInFilterL(iAppList[i].iUid); 

			}

		CLbtContainerListOptions* containerListOptions = CLbtContainerListOptions::NewL(listOptions, containerFilter);

		CleanupStack::PushL(containerListOptions);

		CleanupStack::Pop(4); // containerListOptions, containerFilter, attributeFilter & listOptions

		iContainer.ListTriggers(containerListOptions, iTriggerEntries, iOpId, iStatus);

		SetActive();		

		}

	}

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

// CLbtAppChangeHandler::ListTriggersOfStartupProcessL

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

//

void CLbtAppChangeHandler::ListTriggersOfStartupProcessL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::ListTriggersOfStartupProcessL");

	CLbtListTriggerOptions* listOptions = CLbtListTriggerOptions::NewL();

	CleanupStack::PushL(listOptions);

	CLbtTriggerFilterByAttribute* attributeFilter = 

	                                CLbtTriggerFilterByAttribute::NewL();

	CleanupStack::PushL(attributeFilter);

	attributeFilter->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

	listOptions->SetFilter(attributeFilter);

	// Retreive only the trigger id of the trigger

	TLbtTriggerAttributeFieldsMask mask = CLbtTriggerEntry::EAttributeId;

	listOptions->SetRetrievedFields(mask, 0);

	CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL();

	CleanupStack::PushL(containerFilter);

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

		{

		containerFilter->AddStartupProcessInFilterL( iAppList[i].iFullName );

		}

	CLbtContainerListOptions* containerListOptions = CLbtContainerListOptions::NewL(listOptions, containerFilter);

	CleanupStack::PushL(containerListOptions);

	CleanupStack::Pop(4); // containerListOptions, containerFilter, attributeFilter & listOptions

	iContainer.ListTriggers(containerListOptions, iTriggerEntries, iOpId, iStatus);

	SetActive();

	}

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

// CLbtAppChangeHandler::DeleteTriggersOfStartupProcessL

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

//

void CLbtAppChangeHandler::DeleteTriggersOfStartupProcessL()

	{

	FUNC_ENTER("CLbtAppChangeHandler::DeleteTriggersOfStartupProcessL");

	CLbtContainerUpdateFilter* updateOptions = CLbtContainerUpdateFilter::NewL();

	CleanupStack::PushL(updateOptions);

	CLbtTriggerFilterByAttribute* attributeFilter = 

	                                CLbtTriggerFilterByAttribute::NewL();

	CleanupStack::PushL(attributeFilter);

	attributeFilter->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);

	updateOptions->SetTrigInfoFilter(attributeFilter);

	CLbtContainerFilter* containerFilter = CLbtContainerFilter::NewL();

	CleanupStack::PushL(containerFilter);

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

		{

		containerFilter->AddStartupProcessInFilterL( iAppList[i].iFullName );

		}

	updateOptions->SetContainerFilter(containerFilter);

	CleanupStack::Pop(3); // containerFilter, attributeFilter & updateOptions

	iContainer.DeleteTriggers(updateOptions, iOpId, iStatus);

	SetActive();

	}

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

// CLbtAppChangeHandler::IsMemoryCardPresent

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

//

TBool CLbtAppChangeHandler::IsMemoryCardPresent()

	{

	FUNC_ENTER("CLbtAppChangeHandler::IsMemoryCardPresent");

	//retrieve memory card identifier

    TInt drive;    

    TInt err = DriveInfo::GetDefaultDrive(

           DriveInfo::EDefaultRemovableMassStorage, drive); 

    if( err != KErrNone )

            return EFalse;

    //connect to file server

    RFs fs;

    err = fs.Connect();

    if(err != KErrNone)

        {

        return EFalse;

        }

    //check if memory card is present

    TUint status;

    err = DriveInfo::GetDriveStatus( fs, drive, status );

    fs.Close();

    if( err != KErrNone )

        return EFalse;

    return ( status & DriveInfo::EDrivePresent );

	}

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

// void CLbtAppChangeHandler::MemoryCardChar()

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

//

void CLbtAppChangeHandler::MemoryCardChar()

    {

    TInt drive;    

    TInt err = DriveInfo::GetDefaultDrive(

            DriveInfo::EDefaultRemovableMassStorage, drive); 

    //if memory card is not supported

    if( err!=KErrNone )

        {

        iMMCDriveChar.Copy(KMMCErrorChar);

        return;

        }

    //retrieve memory card character

    RFs fs;

    err = fs.Connect();