/*

* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Definition of the CInstallationPlanner

*

*/

/**

 @file

*/

#include "planner.h"

#include "application.h"

#include "plan.h"

#include "siscontentprovider.h"

#include "sisinstallblock.h"

#include "siscontroller.h"

#include "sisstring.h"

#include "sisinstallationresult.h"

#include "sissupportedlanguages.h"

#include "sislanguage.h"

#include <swi/msisuihandlers.h>

#include "sisregistryfiledescription.h"

#include "sisuid.h"

#include "sisinfo.h"

#include "dessisdataprovider.h"

#include "cleanuputils.h"

#include <swi/msisuihandlers.h>

#include "log.h"

#include "securitycheckutil.h"

#include <f32file.h>

#include "securitymanager.h"

#include "sisregistrydependency.h"

#include "uninstallationnode.h"

using namespace Swi;

using namespace Swi::Sis;

/**

 * Utility Function: This function will append the source array into the target array 

 */ 

template<typename T>

void AppendArrayL(RPointerArray<T>& aTarget, RPointerArray<T>& aSource)

	{

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

		{

		aTarget.AppendL(aSource[i]); 

		}

	}

/**

 * This creates a new CPlanner object.

 * @param aUiHandler An implementation of the UI

 * @param aResult    Result of uninstallation

 * @return           New object

 */

CPlanner* CPlanner::NewL(RUiHandler& aUiHandler, CInstallationResult& aResult)

	{

	CPlanner* self = CPlanner::NewLC(aUiHandler, aResult);

	CleanupStack::Pop(self);

	return self;

	}

/**

 * This creates a new CPlanner object.

 * @param aUiHandler An implementation of the UI

 * @param aResult    Result of installation

 * @return           New object on the cleanup stack

 */

CPlanner* CPlanner::NewLC(RUiHandler& aUiHandler, CInstallationResult& aResult)

	{

	CPlanner* self = new(ELeave) CPlanner(aUiHandler, aResult);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

 * The destructor.

 */

CPlanner::~CPlanner()

	{

	delete iPlan;

	iRegistrySession.Close();

	}

/**

 * The constructor.

 * @param aUiHandler A UI implementation

 * @param aResult    Result of installation

 */

CPlanner::CPlanner(RUiHandler& aUiHandler, CInstallationResult& aResult) 

	:iSystemDriveChar(RFs::GetSystemDriveChar()),

	iUiHandler(aUiHandler), 

	iResult(aResult)

	{

	}

/** 

 * Second phase constructor.

 * Builds the CAppInfo structure.

 */

void CPlanner::ConstructL()

	{

	iPlan = CPlan::NewL();

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

	}

/**

 * Aborts the installation or uninstallation.

 */

void CPlanner::AbortL()

	{

	// Revised design NEVER generates aborted events.

	// CHandleInstallEvent* installEventCmd = CHandleInstallEvent::NewLC(iPlan->AppInfoL() , EEventAbortedUnInstall, 0, KNullDesC);

	// iUiHandler.ExecuteL(*installEventCmd);

	User::Leave(KErrCancel);

	}

/**

 * Displays the dialog warning that there are packages still on the device

 * which depend on the package being uninstalled and so may no longer work if this

 * package is removed.

 * @param aDependentPackages dependent packages.

 */

void CPlanner::DisplayDependentPackagesDialogL(const RPointerArray<CSisRegistryPackage>& aDependentPackages) const

	{

	if (aDependentPackages.Count())

		{

		RPointerArray<TDesC> dependencyNames;

		CleanupClosePushL(dependencyNames);

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

			{

			User::LeaveIfError(dependencyNames.Append(&aDependentPackages[i]->Name()));

			}

		CDisplayDependencyBreak* dialog=CDisplayDependencyBreak::NewLC(iPlan->AppInfoL(), dependencyNames);

		iUiHandler.ExecuteL(*dialog);

		if (!dialog->ReturnResult())

			{

			User::Leave(KErrCancel); // Installation cancelled

			}

		CleanupStack::PopAndDestroy(2, &dependencyNames);

		}

	}

/**

 * Sets the final value of the progress bar.

 *

 * @param aFinalValue The value to use as the final value of the bar.

 */

void CPlanner::SetProgressBarFinalValueL(TInt aFinalValue)

	{

	// Send an event to set the size of the progress bar

	CHandleInstallEvent* event=CHandleInstallEvent::NewLC(iPlan->AppInfoL(), EEventSetProgressBarFinalValue, aFinalValue, KNullDesC);

	iUiHandler.ExecuteL(*event);

	if (!event->ReturnResult())

		{

		User::Leave(KErrCancel);

		}

	CleanupStack::PopAndDestroy(event);

	}

/**

 * Sets up the application information based on a registry entry.

 *

 * @param aRegistryEntry The registry entry to use for the information.

 */

void CPlanner::SetupApplicationInformationL(RSisRegistryEntry& aRegistryEntry)

	{

	// Setup the main AppInfo for giving information about the app to the ui.

	HBufC* vendorName=aRegistryEntry.LocalizedVendorNameL();

	CleanupStack::PushL(vendorName);

	HBufC* applicationName=aRegistryEntry.PackageNameL();

	CleanupStack::PushL(applicationName);

	iPlan->SetApplicationInformationL(*applicationName, *vendorName, aRegistryEntry.VersionL());

	CleanupStack::PopAndDestroy(2, vendorName); 

	}

/**

 * Transfers ownership of the plan from this object.

 */

CPlan* CPlanner::TransferPlanOwnership()

	{

	CPlan* plan=iPlan;

	iPlan=0;

	return plan;

	}

/**

 * This function manages the creation of uninstallation tree where each node 

 * corresponds to a package which may be uninstalled. 

 * 

 * @param aRootNode Root package to be uninstalled.

 */

void CPlanner::CreateUninstallationTreeL(CUninstallationNode& aRootNode)

	{

	RPointerArray<CUninstallationNode> unprocessedTreeNodes;

	CleanupClosePushL(unprocessedTreeNodes);

	CUninstallationNode* currentNode = &aRootNode;

	// PlannedPackages is used to avoid duplicate node in the uninstallation

	// tree.

	RPointerArray<CSisRegistryPackage> plannedPackages;

	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(plannedPackages);

	// Add the root node in the planned packages, so that it is not added again (as a node in the tree)

	// in case of a cyclic dependency.	

	CSisRegistryPackage* rootPackage = CSisRegistryPackage::NewL(currentNode->PackageL());

	plannedPackages.AppendL(rootPackage);

	while(ETrue)

		{

		// plannedPackages is used to avoid creation of duplicate nodes in the tree

		CreateChildNodesL(*currentNode, plannedPackages);

		// After processing currentNode its child nodes should be processed.

		// Therefore append child nodes of currentNode to unprocessedTreeNodes

		AppendArrayL(unprocessedTreeNodes, currentNode->ChildNodes());

		TInt index = unprocessedTreeNodes.Count() - 1;

		if(index < 0)

			{

			break;

			}

		// Here we are processing the array from the end to make it a "Depth First Search"

		currentNode = unprocessedTreeNodes[index];

		unprocessedTreeNodes.Remove(index);

		}

	CleanupStack::PopAndDestroy(&plannedPackages);	

	CleanupStack::PopAndDestroy(&unprocessedTreeNodes);

	}

/**

 * Packages that are embedded by, augmentations to or are depended on by the 

 * package argument passed in (aParentNode) are all added as child nodes to 

 * aParentNode.

 * 

 * @param aAppToProcess Package which has its associated packages investigated.

 * @param aPlannedPackages List of planned packages. This variable is used to avoid creation of duplicate 

 * 			nodes in the tree. 

 */

void CPlanner::CreateChildNodesL(CUninstallationNode& aParentNode, RPointerArray<CSisRegistryPackage>& aPlannedPackages)

	{

	RSisRegistryWritableEntry registryEntry;

	User::LeaveIfError(registryEntry.OpenL(iRegistrySession, aParentNode.PackageL()));

	CleanupClosePushL(registryEntry);

	RPointerArray<CSisRegistryPackage> processPackages;

	CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(processPackages);

	// Go through embedded packages, add them to this aParentNode and append their CUninstallationNode to aResultsArray.  

	// Set them to "Not Planned", and do minimal setup

	// During uninstallation of embedding package embedded packages should also be removed unless there is some

	// dependency.

	registryEntry.EmbeddedPackagesL(processPackages);

	CreateNewNodesL(processPackages, aParentNode, aPlannedPackages);

	processPackages.ResetAndDestroy();

	// If the aParentNode represents a base package then grab all augmentations and

	// add them to aParentNode also append their CUninstallationNode to aResultsArray

	TBool isBasePackage = (registryEntry.InstallTypeL() == Sis::EInstInstallation) || 

						  (registryEntry.InstallTypeL() == Sis::EInstPartialUpgrade) || 

						  (registryEntry.InstallTypeL() == Sis::EInstPreInstalledApp);

	if (isBasePackage && !aParentNode.IsRomUpgrade())

		{

		registryEntry.AugmentationsL(processPackages);

		CreateNewNodesL(processPackages, aParentNode, aPlannedPackages);

		processPackages.ResetAndDestroy();

		}

	//Go through all packages we are dependent on and add them to aParentNode also append their CUninstallationNode to aResultsArray

	CSecurityPolicy* secPolicy = CSecurityPolicy::GetSecurityPolicyL();

	// If RemoveOnlyWithLastDependent is false then we should not check for dependencies.

	if(secPolicy->RemoveOnlyWithLastDependent() 

			&& ((registryEntry.InstallTypeL() == Sis::EInstInstallation) 

			|| (registryEntry.InstallTypeL() == Sis::EInstPartialUpgrade)

			|| (registryEntry.InstallTypeL() == Sis::EInstAugmentation)))

		{

		RPointerArray<CSisRegistryDependency> dependencyList;

		CleanupResetAndDestroy<RPointerArray<CSisRegistryDependency> >::PushL(dependencyList);

		// Retrieve all the dependencies for this package.

		// If B is in A's dependency list then this call for A will retrieve B.

		registryEntry.DependenciesL(dependencyList);

		RSisRegistryWritableEntry depRegistryEntry;

		CSisRegistryPackage *tempPackage = NULL;

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

			{	

			TInt err = depRegistryEntry.Open(iRegistrySession, dependencyList[i]->Uid());

			if(KErrNone != err)

				{

				continue;

				}

			CleanupClosePushL(depRegistryEntry);

			tempPackage = depRegistryEntry.PackageL();

			CleanupStack::PushL(tempPackage);

			processPackages.AppendL(tempPackage);

			CleanupStack::Pop(tempPackage);

			CleanupStack::PopAndDestroy(&depRegistryEntry);

			}

		CleanupStack::PopAndDestroy(&dependencyList);

		CreateNewNodesL(processPackages, aParentNode, aPlannedPackages);

		processPackages.ResetAndDestroy();

		}

	CleanupStack::Pop(&processPackages);

	CleanupStack::PopAndDestroy(&registryEntry);

	}

/**

 * Takes a collection of package details and instantiates CUninstallationNode objects

 * (uninstallation node) in a pending state, adding them to the uninstallation tree.

 * 

 * @param aProcessPackages Collection of package details to be added to the tree structure for planning.

 * @param aParentNode Takes ownership of the resulting CUninstallationNode objects.

 * @param aPlannedPackages List of planned packages. This variable is used to avoid creation of duplicate 

 * 			nodes in the tree. 

 */

void CPlanner::CreateNewNodesL(RPointerArray<CSisRegistryPackage>& aProcessPackages, CUninstallationNode& aParentNode, RPointerArray<CSisRegistryPackage>& aPlannedPackages)

	{

	// We are removing items from array (aProcessPackages)and thus require index 

	// adjustment. But if loop run in reverse order there is no need to adjust the index

	for (TInt i = aProcessPackages.Count() - 1; i >= 0; --i)

		{

		// Ignore already added package

		if (IsInPlannedPackages(aPlannedPackages, *aProcessPackages[i]))

			{

			continue;

			}

		RSisRegistryWritableEntry registryEntry;

		TRAPD(retValue, retValue = registryEntry.OpenL(iRegistrySession, *aProcessPackages[i]));

		if( (KErrNotFound == retValue) || (KErrPathNotFound == retValue))

			{

			// The package has already been removed.

			continue;

			}

		User::LeaveIfError(retValue);

		CleanupClosePushL(registryEntry);

		if (registryEntry.IsInRomL())

			{

			DEBUG_PRINTF2(_L8("Failed to plan this package for uninstall. Is in ROM; Uid: '0x%08x'"),aProcessPackages[i]->Uid().iUid);

			CleanupStack::PopAndDestroy(&registryEntry);

			continue;

			}

		// Don't remove non-removable packages except:-

		// non-removable patches (SP+NR) where the base is is the root package being uninstalled 

		if (!registryEntry.RemovableL() && 

			!(aParentNode.PackageL().Uid() == registryEntry.UidL() && registryEntry.IsAugmentationL()))

			{

			DEBUG_PRINTF2(_L("Cannot uninstall non-removable application; Uid: '0x%08x'"),aProcessPackages[i]->Uid().iUid);

			CleanupStack::PopAndDestroy(&registryEntry);

			continue;	

			}

		CUninstallationNode* newNode = CUninstallationNode::NewLC(registryEntry, *aProcessPackages[i]);

		aParentNode.AddNodeAsChildL(newNode);

		CleanupStack::Pop(newNode);

		aPlannedPackages.AppendL(aProcessPackages[i]);

		// Ownership is transfered from aProcessPackages to aPlannedPackages

		aProcessPackages.Remove(i);

		CleanupStack::PopAndDestroy(&registryEntry);

		}

	}

/**

 * This functions determines whether it is now okay to confirm the removal of the package(Node in the uninstallation tree).  

 * 

 * @param aAppToProcess Package which has its associated packages investigated.

 * @return ETrue If the package is marked for uninstallation else EFalse.

 */

TBool CPlanner::ValidateUninstallationCandidateL(CUninstallationNode& aCandidate, RPointerArray<CSisRegistryPackage>& aPlannedPackages)

	{

	DEBUG_PRINTF4(_L("Checking whether application can be planned for uninstallation or not; Uid: '0x%08x', Name: '%S', Vendor: '%S'"),

						aCandidate.PackageL().Uid(),

						&(aCandidate.PackageL().Name()),

						&(aCandidate.PackageL().Vendor()));

	RSisRegistryWritableEntry registryEntry;

	User::LeaveIfError(registryEntry.OpenL(iRegistrySession, aCandidate.PackageL()));

	CleanupClosePushL(registryEntry);

	TBool result = ETrue;

	CSecurityPolicy* secPolicy = CSecurityPolicy::GetSecurityPolicyL();

	// RemoveOnlyWithLastDependent 

	//

	// If true, when uninstalling a package which embeds another package, 

	// the embedded package is not removed if a third package is dependent on it.

	//

	// If false, the embedded package is removed along with the embedding 

	// package, even if another package depends on it.

	// So we need not check for any depandants for this package and can be 

	// planned for removal

	if (!secPolicy->RemoveOnlyWithLastDependent())

		{

		// When secPolicy->RemoveOnlyWithLastDependent() is false then packages to be removed

		// will not contain any dependant package so we can remove all the packages.

		if (!aCandidate.IsRomUpgrade()) 

			{

			DisplayDependentPackagesDialogL(aCandidate.DependentPackages());

			}

		ConfirmForUninstallL(aCandidate, aPlannedPackages);

		}

	else

		{

		if ((registryEntry.InstallTypeL() != Sis::EInstInstallation) && (registryEntry.InstallTypeL() != Sis::EInstPartialUpgrade))

			{

			// Augmentations will always be removed

			ConfirmForUninstallL(aCandidate, aPlannedPackages); 	

			}

		else

			{

			// RemoveWithLastDependentL will return true only when base package of this package is already uninstalled

			// or it is in the current planned package list (aPlannedPackages).

			// This shows that this embedded package was not removed when the base package waremoved because

			// some packages which depends on this package is not uninstalled or not present in the current 

			// planned package list.

			// If RemoveWithLastDependentL returns true then this package can be confirmed for uninstallation only when

			// all its dependants are already uninstalled or are present in the planned package list.

			if (registryEntry.RemoveWithLastDependentL() && aCandidate.AllDependantsCovered(aPlannedPackages))

				{

				aCandidate.SetRemoveOnEmbeddedL();

				ConfirmForUninstallL(aCandidate, aPlannedPackages); 

				}

			else

				{

				result = EFalse;

				}

			}

		}

	CleanupStack::PopAndDestroy(&registryEntry);

	return result;

	}

/**

 * This is a recursive function which will create CApplication tree.

 * It will walk through the entire uninstallation tree and create

 * tree of CApplication for all the planned nodes.

 * 

 * @param aRootNode Root node of uninstallation tree.

 * @return CApplication pointer corresponding to the aRootNode.

 */

CApplication* CPlanner::CreatePlannedApplicationL(CUninstallationNode& aRootNode)

	{

	CApplication* rootApplication = CApplication::NewLC();

	RPointerArray<CUninstallationNode>& nodes = aRootNode.ChildNodes();

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

		{

		if(!nodes[i]->IsPlanned())

			{

			continue;

			}

		CApplication* child = CreatePlannedApplicationL(*nodes[i]);

		CleanupStack::PushL(child);

		rootApplication->AddEmbeddedApplicationL(child);

		CleanupStack::Pop(child);

		}

	UpdateAppForUninstallL(*rootApplication, aRootNode);

	if(!(Swi::SecUtils::IsPackageUidPresent(aRootNode.PackageL().Uid(), iUidList)))

	    {

	    TInt err = SecUtils::PublishPackageUid(aRootNode.PackageL().Uid(), iUidList);

		if(err==KErrNone)

            {

            DEBUG_PRINTF2(_L("CPlanner::CreatePlannedApplicationL published Uid is %x."),aRootNode.PackageL().Uid());

		    }

		else if(err == KErrOverflow)

		    {

            DEBUG_PRINTF2(_L("CPlanner::CreatePlannedApplicationL failed to publish Uid %x as the array, holding the uids, exceeded its upper limit."),aRootNode.PackageL().Uid());

		    }

        else if(err == KErrNotFound)

            {

            DEBUG_PRINTF2(_L("CPlanner::CreatePlannedApplicationL failed to publish Uid %x as the property is not defined."),aRootNode.PackageL().Uid());

            }

		else

		    {

            DEBUG_PRINTF3(_L("CPlanner::CreatePlannedApplicationL failed to publish Uid %x with error."),aRootNode.PackageL().Uid(), err);

            User::Leave(err);

		    }

		}

	CleanupStack::Pop(rootApplication);