// swi.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

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

// Accenture - Initial contribution

//

#include "swi.h"

#include <fshell/common.mmh>

#include <fshell/ltkutils.h>

typedef TBuf<1> TUserInput;

_LIT(KSwiYes,	"y");

_LIT(KSwiNo,	"n");

_LIT(KSwiJarExtension,	"*.jar");

_LIT(KSwiJadExtension,	"*.jad");

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

_LIT8(KDefaultJadMimeType, "text/vnd.sun.j2me.app-descriptor");

_LIT8(KDefaultJarMimeType, "application/java-archive");

#endif

_LIT(KDefaultMatch, "*");

//

// CCmdSwi

// class to handle the fshell console user interaction

//

CCommandBase* CCmdSwi::NewLC()

	{

	CCmdSwi* self = new(ELeave) CCmdSwi();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdSwi::~CCmdSwi()

	{

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

	delete iMidletHandler;

#endif

	delete iSisHandler;

	delete iMatch;

	}

CCmdSwi::CCmdSwi():

CCommandBase(CCommandBase::EManualComplete)

	{

	SetExtension(this);

	}

const TDesC& CCmdSwi::Name() const

	{

	_LIT(KName, "swi");

	return KName;

	}

void CCmdSwi::ArgumentsL(RCommandArgumentList& aArguments)

	{

	aArguments.AppendEnumL((TInt&)iCommand, _L("operation"));

	_LIT(KArgFilename, "sis-file");

	aArguments.AppendFileNameL(iSisFile, KArgFilename);

	}

void CCmdSwi::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptUid, "uid");

	aOptions.AppendUintL((TUint&)iUid.iUid, KOptUid);

	_LIT(KOptVerbose, "verbose");

	aOptions.AppendBoolL(iVerbose, KOptVerbose);

	_LIT(KOptQuiet, "quiet");

	aOptions.AppendBoolL(iQuiet, KOptQuiet);

	_LIT(KOptMatch, "match");

	aOptions.AppendStringL(iMatch, KOptMatch);

	}

void CCmdSwi::DoRunL()

	{

	if (iMatch == NULL)

		{

		iMatch = KDefaultMatch().AllocL();

		}

	iSisHandler = CSwiSisInstallerAO::NewL(*this, FsL(), iVerbose, iQuiet);

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

	iMidletHandler = CSwiMidletInstallerAO::NewL(*this, FsL(), iVerbose, iQuiet);

#endif

	switch (iCommand)

		{

	case EList:

		//TODO matching

		TRAPL(iSisHandler->ListInstalledAppsL(iUid, *iMatch), _L("Couldn't list installed SIS files"));

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

		TRAPL(iMidletHandler->ListInstalledAppsL(iUid, *iMatch), _L("Couldn't list installed midlets"));

#endif

		Complete(KErrNone);

		break;

	case EUninstall:

		if (!iOptions.IsPresent(&iUid))

			{

			LeaveIfErr(KErrArgument, _L("UID must be specified for \"uninstall\""));

			}

		TRAPD(error, iSisHandler->UninstallL(iUid));

		if (error != KErrNone)

			{

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

			// possibly a midlet

			TRAP(error, iMidletHandler->UninstallL(iUid));

#endif

			}

		LeaveIfErr(error, _L("Failed to uninstall package 0x%08x"), iUid.iUid);

		break;

	case EInstall:

		if (!iArguments.IsPresent(1))

			{

			LeaveIfErr(KErrArgument, _L("SIS file must be specified for \"install\""));

			}

		User::LeaveIfError(Stdin().SetReadMode(RIoReadHandle::ELine));

#ifndef SYMBIAN_JAVA_NOT_INCLUDED

		if (IsMidlet())

			{

			TRAPL(iMidletHandler->InstallL(iSisFile), _L("Failed to install midlet '%S'"), &iSisFile);

			}

		else

#endif

			{

			TRAPL(iSisHandler->InstallL(iSisFile), _L("Failed to install sis '%S'"), &iSisFile);

			}

		break;

		}

	}

TBool CCmdSwi::IsMidlet()

	{

	if ((iSisFile.MatchF(KSwiJarExtension) != KErrNotFound) || (iSisFile.MatchF(KSwiJadExtension) != KErrNotFound))

		return ETrue;

	return EFalse;

	}

//

// CCmdSwi::GetAnswer

// only for use when not in quiet mode

// Reads input from stdin, determines whether it's a 'yes' or 'no', returning ETrue, EFalse respectively

//

TBool CCmdSwi::GetAnswer()

	{

	ASSERT(!iQuiet);

	TUserInput in;

	for (;;)

		{

		if (Stdin().Read(in) != KErrNone)

			{

			return EFalse;

			}

		Stdout().Write(in);

		if (in.MatchF(KSwiYes) == 0)

			{

			return ETrue;

			}

		if (in.MatchF(KSwiNo) == 0)

			{

			return EFalse;

			}

		// else it's an unrecognised response

		}

	}

//

// MCmdSwiParent hooks

//

RIoConsoleReadHandle& CCmdSwi::Input()

	{

	return Stdin();

	}

RIoConsoleWriteHandle& CCmdSwi::Output(TInt aError)

	{

	if (aError == KErrNone)

		{

		return Stdout();

		}

	return Stderr();

	}

//

// CCmdSwi::Finished

// callback from the underlying AO's RunL

//

void CCmdSwi::Finished(TInt aError)

	{

	Complete(aError);

	}

#define CASE_RETURN_LIT(XXX, YYY) case XXX: { _LIT(_KLit, #YYY); return &_KLit; }

const TDesC* CCmdSwi::StringifyError(TInt aError) const

	{

	switch (aError)

		{

		CASE_RETURN_LIT(-10100, KErrSISFieldIdMissing);

		CASE_RETURN_LIT(-10101, KErrSISFieldLengthMissing);

		CASE_RETURN_LIT(-10102, KErrSISFieldLengthInvalid);

		CASE_RETURN_LIT(-10103, KErrSISStringInvalidLength);

		CASE_RETURN_LIT(-10104, KErrSISSignedControllerSISControllerMissing);

		CASE_RETURN_LIT(-10105, KErrSISControllerSISInfoMissing);

		CASE_RETURN_LIT(-10106, KErrSISInfoSISUidMissing);

		CASE_RETURN_LIT(-10107, KErrSISInfoSISNamesMissing);

		CASE_RETURN_LIT(-10108, KErrSISFieldBufferTooShort);

		CASE_RETURN_LIT(-10109, KErrSISStringArrayInvalidElement);

		CASE_RETURN_LIT(-10110, KErrSISInfoSISVendorNamesMissing);

		CASE_RETURN_LIT(-10111, KErrSISInfoSISVersionMissing);

		CASE_RETURN_LIT(-10112, KErrSISControllerSISSupportedLanguagesMissing);

		CASE_RETURN_LIT(-10113, KErrSISSupportedLanguagesInvalidElement);

		CASE_RETURN_LIT(-10114, KErrSISLanguageInvalidLength);

		CASE_RETURN_LIT(-10115, KErrSISContentsSISSignedControllerMissing);

		CASE_RETURN_LIT(-10116, KErrSISContentsSISDataMissing);

		CASE_RETURN_LIT(-10117, KErrSISDataSISFileDataUnitMissing);

		CASE_RETURN_LIT(-10118, KErrSISFileDataUnitTargetMissing);

		CASE_RETURN_LIT(-10119, KErrSISFileOptionsMissing);

		CASE_RETURN_LIT(-10120, KErrSISFileDataUnitDescriptorMissing);

		CASE_RETURN_LIT(-10121, KErrSISFileDataDescriptionMissing);

		CASE_RETURN_LIT(-10122, KErrSISContentsMissing);

		CASE_RETURN_LIT(-10123, KErrSISEmbeddedControllersMissing);

		CASE_RETURN_LIT(-10124, KErrSISEmbeddedDataUnitsMissing);

		CASE_RETURN_LIT(-10125, KErrSISControllerOptionsMissing);

		CASE_RETURN_LIT(-10126, KErrSISExpressionMissing);

		CASE_RETURN_LIT(-10127, KErrSISExpressionStringValueMissing);

		CASE_RETURN_LIT(-10128, KErrSISOptionsStringMissing);

		CASE_RETURN_LIT(-10129, KErrSISFileOptionsExpressionMissing);

		CASE_RETURN_LIT(-10130, KErrSISExpressionHeadValueMissing);

		CASE_RETURN_LIT(-10131, KErrSISEmbeddedSISOptionsMissing);

		CASE_RETURN_LIT(-10132, KErrSISInfoSISUpgradeRangeMissing);

		CASE_RETURN_LIT(-10133, KErrSISDependencyMissingUid);

		CASE_RETURN_LIT(-10134, KErrSISDependencyMissingVersion);

		CASE_RETURN_LIT(-10135, KErrSISDependencyMissingNames);

		CASE_RETURN_LIT(-10136, KErrSISPrerequisitesMissingDependency);

		CASE_RETURN_LIT(-10137, KErrSISControllerMissingPrerequisites);

		CASE_RETURN_LIT(-10138, KErrSISUpgradeRangeMissingVersion);

		CASE_RETURN_LIT(-10139, KErrSISUnexpectedFieldType);

		CASE_RETURN_LIT(-10140, KErrSISExpressionUnknownOperator);

		CASE_RETURN_LIT(-10141, KErrSISArrayReadError);

		CASE_RETURN_LIT(-10142, KErrSISArrayTypeMismatch);

		CASE_RETURN_LIT(-10143, KErrSISInvalidStringLength);

		CASE_RETURN_LIT(-10144, KErrSISCompressionNotSupported);

		CASE_RETURN_LIT(-10145, KErrSISTooDeeplyEmbedded);

		CASE_RETURN_LIT(-10146, KErrSISInvalidTargetFile);

		CASE_RETURN_LIT(-10147, KErrSISWouldOverWrite);

		CASE_RETURN_LIT(-10148, KErrSISInfoMissingRemoveDirectories);

		CASE_RETURN_LIT(-10149, KErrSISNotEnoughSpaceToInstall);

		CASE_RETURN_LIT(-10200, KErrInstallerLeave);

		CASE_RETURN_LIT(-10250, KErrPolicyFileCorrupt);

		CASE_RETURN_LIT(-10251, KErrSignatureSchemeNotSupported);

		CASE_RETURN_LIT(-10252, KErrDigestNotSupported);

		CASE_RETURN_LIT(-10253, KErrBadHash);

		CASE_RETURN_LIT(-10254, KErrSecurityError);

		CASE_RETURN_LIT(-10263, KErrBadUsage);

		CASE_RETURN_LIT(-10260, KErrInvalidType); 

		CASE_RETURN_LIT(-10261, KErrInvalidExpression); 

		CASE_RETURN_LIT(-10262, KErrExpressionToComplex); 

		CASE_RETURN_LIT(-10255, KErrMissingBasePackage); 

		CASE_RETURN_LIT(-10256, KErrInvalidUpgrade); 

		CASE_RETURN_LIT(-10257, KErrInvalidEclipsing);

		CASE_RETURN_LIT(-10258, KErrWrongHeaderFormat);

		CASE_RETURN_LIT(-10259, KErrCapabilitiesMismatch); 

		CASE_RETURN_LIT(-10270, KErrLegacySisFile);

		CASE_RETURN_LIT(-10271, KErrInvalidSoftwareTypeRegistrationFile); 

		default:

			return NULL;

		}

	}

//

// Sis installer AO

//

CSwiSisInstallerAO* CSwiSisInstallerAO::NewL(MCmdSwiParent& aParent, RFs& aFs, TBool aVerbose, TBool aQuiet)

	{

	CSwiSisInstallerAO* self = new (ELeave) CSwiSisInstallerAO(aParent, aFs, aVerbose, aQuiet);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CSwiSisInstallerAO::CSwiSisInstallerAO(MCmdSwiParent& aParent, RFs& aFs, TBool aVerbose, TBool aQuiet)

	: CActive(CActive::EPriorityStandard), iParent(aParent), iVerbose(aVerbose), iQuiet(aQuiet), iCurrentDrive('c')

	{

	TFileName sessionPath;

	TInt err = aFs.SessionPath(sessionPath);

	if (err == KErrNone)

		{

		iCurrentDrive = sessionPath[0];

		iCurrentDrive.LowerCase();

		}

	CActiveScheduler::Add(this);

	}

CSwiSisInstallerAO::~CSwiSisInstallerAO()

	{

	Cancel();

	delete iLauncher;

	delete iRegPackage;

	iRegistrySession.Close();

	delete iPrefs;

	}

void CSwiSisInstallerAO::ConstructL()

	{

	iLauncher = CAsyncLauncher::NewL();

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

	iPrefs = Swi::CInstallPrefs::NewL();

	iPrefs->SetPerformRevocationCheck(EFalse); // TODO - not currently supported in CCmdSwi

	}

void CSwiSisInstallerAO::RunL()

	{

	iParent.Finished(iStatus.Int());

	}

void CSwiSisInstallerAO::DoCancel()

	{

	iLauncher->CancelOperation();

	iParent.Finished(KErrCancel);

	}

void CSwiSisInstallerAO::PrintDetails(Swi::CSisRegistryPackage& aPackage)

	{

	if (iVerbose)

		{

		TName myBuf;

		myBuf.Format(_L("\r\nName:\t%S\r\n"), &aPackage.Name());

		Stdout().Write(myBuf);

		myBuf.Format(_L("Vendor:\t%S\r\n"), &aPackage.Vendor());

		Stdout().Write(myBuf);

		myBuf.Format(_L("Uid:\t0x%x\r\n"), aPackage.Uid());

		Stdout().Write(myBuf);

		}

	else

		{

		TBuf<256> buf; buf.Format(_L("0x%08x: "), aPackage.Uid());

		Stdout().Write(buf);

		Stdout().Write(aPackage.Name());

		Stdout().Write(_L("\r\n"));

		}

	}

void CSwiSisInstallerAO::InstallL(TFileName& aInstallFile)

	{

	// install regular sis file

	ASSERT(iPrefs);

	ASSERT(iLauncher);

	iLauncher->InstallL(*this, aInstallFile, *iPrefs, iStatus);

	SetActive();

	}

void CSwiSisInstallerAO::UninstallL(const TUid& aPackageUid)

	{

	// remove regular sis file

	ASSERT(iLauncher);

	ASSERT(!iRegPackage);

	Swi::CSisRegistryPackage* iRegPackage = GetSisRegistryPackageL(aPackageUid);

	iLauncher->UninstallL(*this, *iRegPackage, iStatus);

	SetActive();

	}

//

// CSwiSisInstallerAO::ListInstalledAppsL

// lists apps currently installed on the device

//

void CSwiSisInstallerAO::ListInstalledAppsL(const TUid& aAppUid, const TDesC& aMatchString)

	{

	if (aAppUid.iUid != 0)

		{

		DisplayPackageL(aAppUid);

		}

	else

		{

		ASSERT(iRegistrySession.Handle() > 0);

		RPointerArray<CSisRegistryPackage> packages;

		LtkUtils::CleanupResetAndDestroyPushL(packages);

		iRegistrySession.InstalledPackagesL(packages);

		if (packages.Count() <= 0)

			{

			User::Leave(KErrNotFound);

			}

		TInt count = 0;

		const TInt endCount = packages.Count();

		do

			{

			CSisRegistryPackage* current = packages[count++];

			if ((current->Name().MatchF(aMatchString) >= 0) || (current->Vendor().MatchF(aMatchString) >= 0))

				{

				PrintDetails(*current);

				}

			} while (count < endCount);

		CleanupStack::PopAndDestroy(&packages);

		}

	}

//

// CSwiSisInstallerAO::DisplayPackageL

// find information on the specified package uid and display it on the console

//

void CSwiSisInstallerAO::DisplayPackageL(const TUid& aPackageUid)

	{

	ASSERT(iRegistrySession.Handle() > 0);

	Swi::RSisRegistryEntry entry;

	User::LeaveIfError(entry.Open(iRegistrySession, aPackageUid));

	CleanupClosePushL(entry);

	Swi::CSisRegistryPackage* registryPackage = entry.PackageL();

	CleanupStack::PushL(registryPackage);

	PrintDetails(*registryPackage);

	CleanupStack::PopAndDestroy(2, &entry);	

	}

//

// CSwiSisInstallerAO::GetSisRegistryPackageL

// locate the sis registry package corresponding to the specified package ui

//

Swi::CSisRegistryPackage* CSwiSisInstallerAO::GetSisRegistryPackageL(const TUid& aPackageUid)

	{

	ASSERT(iRegistrySession.Handle() > 0);

	if (!iRegistrySession.IsInstalledL(aPackageUid))

		{

		User::Leave(KErrNotFound); // invalid uid

		}

	// else iterate through the installed packages to find ours

	RPointerArray<Swi::CSisRegistryPackage> packages;

	iRegistrySession.InstalledPackagesL(packages);

	if (packages.Count() <= 0)

		{

		User::Leave(KErrNotFound);

		}

	TInt count = 0;

	const TInt endCount = packages.Count();

	Swi::CSisRegistryPackage* found = NULL;

	do

		{

		Swi::CSisRegistryPackage* current = packages[count];

		 if (current->Uid() == aPackageUid)

			{

			found = current;

			break;

			}

		count++;

		} while (count < endCount);

	ASSERT(found); // IsInstalledL stated it's in there

	return found; 

	}

//

// SWI UI Hooks

//

TBool CSwiSisInstallerAO::DisplayTextL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TFileTextOption /*aOption*/, const TDesC& aText)

	{

	TBool response = ETrue; // default, the user will continue with the installation/uninstallation

	if (!iQuiet)

		{

		Stdout().Write(aText);

		Stdout().Write(_L("Continue [y/n]?\r\n"));

		response = iParent.GetAnswer();

		}

	return response;

	}

void CSwiSisInstallerAO::DisplayErrorL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TErrorDialog aType, const TDesC& /*aParam*/)

	{

	if (iVerbose)

		{

		switch (aType)

			{

			case Swi::EUiAlreadyInRom:

				Stderr().Write(_L("\r\nCannot overwrite a ROM component.\r\n"));

			break;

			case Swi::EUiMissingDependency:

				Stderr().Write(_L("\r\nMissing a dependency.\r\n"));

			break;

			case Swi::EUiRequireVer:

				Stderr().Write(_L("\r\nA dependency exists on a specific version of an application which is different from the one installed.\r\n"));

			break;

			case Swi::EUiFileCorrupt:

				Stderr().Write(_L("\r\nSISX file corrupt. Checksums stored in file do not match actual.\r\n"));

			break;

			case Swi::EUiDiskNotPresent:

				Stderr().Write(_L("\r\nAll your bases are belong to us. <disk not present>\r\n"));

			break;

			case Swi::EUiCannotRead:

				Stderr().Write(_L("\r\nCannot read a file which is needed in order to proceed.\r\n"));

			break;

			case Swi::EUiCannotDelete:

				Stderr().Write(_L("\r\nCannot delete a file.\r\n"));

			break;

			case Swi::EUiInvalidFileName:

				Stderr().Write(_L("\r\nA filename specified in the SISX package is not valid.\r\n"));

			break;

			case Swi::EUiInsufficientSpaceOnDrive:

				Stderr().Write(_L("\r\nInsufficient space on the drive.\r\n"));

			break;

			case Swi::EUiCapabilitiesCannotBeGranted:

				Stderr().Write(_L("\r\nApplication requires system capability it is not signed for.\r\n"));

			break;

			case Swi::EUiUnknownFile:

				Stderr().Write(_L("\r\nNot a recognised SISX file.\r\n"));

			break;