/*
* Copyright (c) 2009-2010 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: 
*     CInstallManager implementation
*
*
*/


#include <swi/swispubsubdefs.h>
#include <swi/sisregistrysession.h>
#include <swi/sisregistryentry.h>
#include <swi/sisregistrypackage.h>
#include <e32base.h>
#include "ADMAppUi.h"
#include "ADMInstallManager.h"

#include "macros.h"
#include "debug.h"

class TSisInfo
	{
public:
	TVersion iVersion;
	TChar iInstalledDrive;
	RArray<TUid> iSids;
	};

_LIT8(KMIME,"x-epoc/x-sisx-app");

#ifdef USE_LOGFILE
CInstallManager* CInstallManager::NewLC(MInstallClient* aInstallClient, RFileLogger& aLogger)
	{
	CInstallManager* object = new ( ELeave ) CInstallManager(aInstallClient, aLogger);
	CleanupStack::PushL( object );
	object->ConstructL();
	return object;
	}

CInstallManager* CInstallManager::NewL(MInstallClient* aInstallClient, RFileLogger& aLogger)
	{
	CInstallManager* object = CInstallManager::NewLC(aInstallClient, aLogger);
	CleanupStack::Pop();
	return object;
	}

CInstallManager::CInstallManager(MInstallClient* aInstallClient, RFileLogger& aLogger) :
	CActive(EPriorityStandard),
	iLog(aLogger),
	iInstallClient(aInstallClient)
	{
	CActiveScheduler::Add(this);
	}
#else
CInstallManager* CInstallManager::NewLC(MInstallClient* aInstallClient)
	{
	CInstallManager* object = new ( ELeave ) CInstallManager(aInstallClient);
	CleanupStack::PushL( object );
	object->ConstructL();
	return object;
	}

CInstallManager* CInstallManager::NewL(MInstallClient* aInstallClient)
	{
	CInstallManager* object = CInstallManager::NewLC(aInstallClient);
	CleanupStack::Pop();
	return object;
	}

CInstallManager::CInstallManager(MInstallClient* aInstallClient) :
	CActive(EPriorityStandard),
	iInstallClient(aInstallClient)
	{
	CActiveScheduler::Add(this);
	}
#endif

CInstallManager::~CInstallManager()
	{
	Cancel();
	iLauncher.Close();
	DELETE_IF_NONNULL( iInstallFilename );
	}

void CInstallManager::RunL()
	{
	if ( ((iStatus.Int() == SwiUI::KSWInstErrBusy )||(iStatus.Int() == KErrInUse) || (iStatus.Int() == KErrServerBusy) ) &&
			((++iInstallAttempt) <= KAttemptsToAccessInstaller) )
		{
		LOG( "CInstallManager: Installer busy, waiting" );
		User::After( KIterationTimer );
		// Start asynchronous silent installation again
		if( !IsActive() )
			{
			SetActive();
			}

		iStatus = KRequestPending;

		iLauncher.SilentInstall( iStatus, *iInstallFilename, iOptionsPckg );
		}
	else
		{
		LOG2( "CInstallManager: Install completed (%d)", iInstallAttempt );
		iInstallClient->HandleInstallCompletedL( iStatus.Int() );
		}
	}

void CInstallManager::DoCancel()
	{
	CancelInstallation();
	CancelUninstallation();
	}

void CInstallManager::ConstructL()
	{
	User::LeaveIfError(iLauncher.Connect());
	}

TBool CInstallManager::IsPackagePresentL( const TUid& aUid )
	{
	TSisInfo sisInfo;
	TBool isInstalled;

	sisInfo = GetPackageInfoL(aUid, isInstalled);

	return isInstalled;
	}

TBool CInstallManager::GetPackageSidsL(const TUid& aUid, RArray<TUid>& aSids)
	{
	TSisInfo sisInfo;
	TBool isInstalled;

	sisInfo = GetPackageInfoL(aUid, isInstalled);

	if (isInstalled)
		{
		aSids = sisInfo.iSids;
		}

	return isInstalled;
	}

TBool CInstallManager::GetPackageInstalledDriveL(const TUid& aUid, TChar& aWrapperDrive)
	{
	TSisInfo sisInfo;
	TBool isInstalled;

	sisInfo = GetPackageInfoL(aUid, isInstalled);

	if (isInstalled)
		{
		aWrapperDrive = sisInfo.iInstalledDrive;
		}

	return isInstalled;
	}

TBool CInstallManager::GetPackageVersionInfoL(const TUid& aUid, TVersion& aVersion)
	{
	TSisInfo sisInfo;
	TBool isInstalled;

	sisInfo = GetPackageInfoL(aUid, isInstalled);

	if (isInstalled)
		{
		aVersion = sisInfo.iVersion;
		}

	return isInstalled;
	}

TSisInfo CInstallManager::GetPackageInfoL(const TUid& aUid, TBool& aIsPkgInstalled)
	{
	TSisInfo sisInfo;
	// Connect to SisRegistry to fetch Package info
	Swi::RSisRegistrySession registrySession;

	User::LeaveIfError( registrySession.Connect() );
	CleanupClosePushL(registrySession);

	aIsPkgInstalled = registrySession.IsInstalledL( aUid );

	if ( aIsPkgInstalled )
		{
		Swi::RSisRegistryEntry entry;

		// Open registry entry to get version information.
		User::LeaveIfError(entry.Open(registrySession, aUid));
		CleanupClosePushL(entry);

		// Get the data
		sisInfo.iVersion = entry.VersionL();
		sisInfo.iInstalledDrive = entry.SelectedDriveL();
		entry.SidsL(sisInfo.iSids);

		CleanupStack::PopAndDestroy(&entry);
		}

	CleanupStack::PopAndDestroy(&registrySession);

	return sisInfo;
	}

void CInstallManager::SilentInstallPackageL(const TDesC& aInstallFilename, const TChar aInstallDrive)
	{
	LOG2( "+ SilentInstallPackage(): '%S'", &aInstallFilename );

	DELETE_IF_NONNULL( iInstallFilename );
	iInstallFilename = aInstallFilename.AllocL();
	iInstallAttempt = 0;

	SwiUI::TInstallOptions Options;

	Options.iUpgrade = SwiUI::EPolicyAllowed;
	Options.iOCSP    = SwiUI::EPolicyNotAllowed;
	RFs::DriveToChar(aInstallDrive, Options.iDrive);
	Options.iUntrusted = SwiUI::EPolicyNotAllowed;
	Options.iCapabilities = SwiUI::EPolicyAllowed;
	Options.iOverwrite = SwiUI::EPolicyAllowed;

	iOptionsPckg = Options;

	// We have to cancel any pending async request, because we might
	// get called during installation (user cancel, for instance)
	if (IsActive())
		{
		Cancel();
		}

	// Start asynchronous silent installation
	iStatus = KRequestPending;
	SetActive();
	iLauncher.SilentInstall( iStatus, *iInstallFilename, iOptionsPckg);
	}

TInt CInstallManager::SilentUnInstallPackage(const TUid& aPkgUid)
	{
	TInt ret;

	SwiUI::TUninstallOptions Options;
	SwiUI::TUninstallOptionsPckg OptionsPckg;

	// TODO: Missing iBreakDependency: Allowed or not?
	Options.iBreakDependency = SwiUI::EPolicyAllowed;
	Options.iKillApp = SwiUI::EPolicyAllowed;
	OptionsPckg = Options;

	// Start silent uninstallation
	// If connection to Install server fails,
	// make KAttemptsToAccessInstaller connection attempts
	for (TInt i = 0; i < KAttemptsToAccessInstaller; i++)
		{
		// Silent Uninstallation
		ret = iLauncher.SilentUninstall( aPkgUid, OptionsPckg, KMIME );

		// SWI returns KErrInUse & KErrServerBusy as well.
		// SwiUI errors are returned as is
		if ( ret == SwiUI::KSWInstErrBusy ||
			 ret == KErrInUse ||
			 ret == KErrServerBusy)
			{
			LOG3( "Installer busy, retrying (%d: %d)", i, ret );
			// Wait a while and then retry the uninstallation again
			User::After( KIterationTimer );
			}
		else
			{
			break;
			}
		}

	return ret;
	}

void CInstallManager::SilentUninstallPackageAsync(const TUid& aPkgUid)
	{
	SwiUI::TUninstallOptions options;

	// TODO: Missing iBreakDependency: Allowed or not?
	options.iBreakDependency = SwiUI::EPolicyAllowed;
	options.iKillApp = SwiUI::EPolicyAllowed;
	iUninstallOptionsPckg = options;

	// We have to cancel any pending async request, because we might
	// get called during uninstallation (user cancel, for instance)
	if (IsActive())
		{
		Cancel();
		}

	// Start asynchronous silent uninstallation
	iStatus = KRequestPending;
	SetActive();
	iLauncher.SilentUninstall( iStatus, aPkgUid, iUninstallOptionsPckg, KMIME );
	}

void CInstallManager::CancelAll()
	{
	Cancel();
	CancelInstallation();
	CancelUninstallation();
	}

TInt CInstallManager::CancelInstallation()
	{
	return iLauncher.CancelAsyncRequest(SwiUI::ERequestSilentInstall);
	}

TInt CInstallManager::CancelUninstallation()
	{
	return iLauncher.CancelAsyncRequest(SwiUI::ERequestSilentUninstall);
	}

TInt CInstallManager::InstallPackage(const TDesC& aInstallFilename)
	{
	LOG2( "+ InstallPackage(): '%S'", &aInstallFilename );

	DELETE_IF_NONNULL( iInstallFilename );
	iInstallFilename = aInstallFilename.AllocL();

	TInt ret;
	SwiUI::RSWInstLauncher Launcher;

	ret = Launcher.Connect();
	if (ret != KErrNone)
		{
		return ret;
		}

	// Start Installation
	// If connection to Install server fails,
	// make KAttemptsToAccessInstaller connection attempts
	for (TInt i = 0; i < KAttemptsToAccessInstaller; i++)
		{
		// Normal installation
		ret = Launcher.Install(*iInstallFilename);

		// SWI returns KErrInUse & KErrServerBusy as well.
		// SwiUI errors are returned as is
		if ( ret == SwiUI::KSWInstErrBusy ||
			 ret == KErrInUse ||
			 ret == KErrServerBusy)
			{
			LOG3( "Installer busy, retrying (%d: %d)", i, ret );
			// Wait a while and then retry the uninstallation again
			User::After( KIterationTimer );
			}
		else
			{
			break;
			}
		}
	Launcher.Close();
	return ret;
	}

TUid CInstallManager::GetPackageUidL(const TUid& aSid)
	{
	// Connect to SisRegistry to fetch Package info
	Swi::RSisRegistrySession registrySession;
	User::LeaveIfError(registrySession.Connect());
	CleanupClosePushL(registrySession);

	Swi::CSisRegistryPackage* pkg = NULL;
	pkg = registrySession.SidToPackageL(aSid);

	CleanupStack::PopAndDestroy(&registrySession);

	TUid uid = TUid::Uid(0);
	if ( pkg )
		{
		uid = pkg->Uid();
		}

	delete pkg;

	return uid;
	}