--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swinstallationfw/examples/refnativeplugin/source/refnativeplugin.cpp Fri Mar 19 09:33:35 2010 +0200
@@ -0,0 +1,713 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+
+#include "refnativeplugin.h"
+#include "usiflog.h"
+#include <usif/sif/sif.h>
+#include <usif/sif/sifcommon.h>
+#include <usif/usiferror.h>
+#include <usif/sif/sifplugin.h>
+#include <usif/scr/screntries.h>
+#include <usif/scr/scr.h>
+#include <swi/msisuihandlers.h>
+#include <swi/asynclauncher.h>
+#include <swi/sisinstallerrors.h>
+#include <e32property.h>
+#include <sacls.h>
+#include "sisregistrywritablesession.h"
+#include "sisregistrysession.h"
+
+using namespace Usif;
+
+static const TInt KRefNativePluginImpId = 0x10285BC4;
+
+static const TImplementationProxy ImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(KRefNativePluginImpId, CRefNativePlugin::NewL)
+ };
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+ {
+ aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+ return ImplementationTable;
+ }
+
+CRefNativePlugin* CRefNativePlugin::NewL()
+ {
+ DEBUG_PRINTF(_L8("Constructing CRefNativePlugin"));
+ CRefNativePlugin *self = new (ELeave) CRefNativePlugin();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CRefNativePlugin::ConstructL()
+ {
+ iImpl = CRefNativePluginActiveImpl::NewL();
+ }
+
+CRefNativePlugin::~CRefNativePlugin()
+ {
+ delete iImpl;
+ }
+
+void CRefNativePlugin::CancelOperation()
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Cancel"));
+ iImpl->Cancel();
+ }
+
+void CRefNativePlugin::GetComponentInfo(const TDesC& aFileName, const TSecurityContext& /*aSecurityContext*/,
+ CComponentInfo& aComponentInfo, TRequestStatus& aStatus)
+ {
+ iImpl->GetComponentInfo(aFileName, aComponentInfo, aStatus);
+ }
+
+void CRefNativePlugin::GetComponentInfo(RFile& aFileHandle, const TSecurityContext& /*aSecurityContext*/,
+ CComponentInfo& aComponentInfo, TRequestStatus& aStatus)
+ {
+ iImpl->GetComponentInfo(aFileHandle, aComponentInfo, aStatus);
+ }
+
+void CRefNativePlugin::Install(const TDesC& aFileName, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,
+ TRequestStatus& aStatus)
+ {
+ iImpl->Install(aFileName, aSecurityContext, aInputParams, aOutputParams, aStatus);
+ }
+
+void CRefNativePlugin::Install(RFile& aFileHandle, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,
+ TRequestStatus& aStatus)
+ {
+ iImpl->Install(aFileHandle, aSecurityContext, aInputParams, aOutputParams, aStatus);
+ }
+
+void CRefNativePlugin::Uninstall(TComponentId aComponentId, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)
+ {
+ iImpl->Uninstall(aComponentId, aSecurityContext, aInputParams, aOutputParams, aStatus);
+ }
+
+void CRefNativePlugin::Activate(TComponentId aComponentId, const TSecurityContext& aSecurityContext, TRequestStatus& aStatus)
+
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Activate"));
+ iImpl->Activate(aComponentId, aSecurityContext, aStatus);
+ }
+
+void CRefNativePlugin::Deactivate(TComponentId aComponentId, const TSecurityContext& aSecurityContext, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Deactivate"));
+ iImpl->Deactivate(aComponentId, aSecurityContext, aStatus);
+ }
+
+//------------------CRefNativePluginActiveImpl---------------------
+
+CRefNativePluginActiveImpl* CRefNativePluginActiveImpl::NewL()
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Constructing CRefNativePluginActiveImpl"));
+ CRefNativePluginActiveImpl *self = new (ELeave) CRefNativePluginActiveImpl();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(1, self);
+ return self;
+ }
+
+void CRefNativePluginActiveImpl::ConstructL()
+ {
+ iInstallPrefs = Swi::CInstallPrefs::NewL();
+ iAsyncLauncher = Swi::CAsyncLauncher::NewL();
+ iComponentInfo = CComponentInfo::NewL();
+ CActiveScheduler::Add(this);
+ }
+
+CRefNativePluginActiveImpl::~CRefNativePluginActiveImpl()
+ {
+ delete iAsyncLauncher;
+ delete iInstallPrefs;
+ delete iComponentInfo;
+ }
+
+const TInt KSystemWideErrorsBoundary = -100;
+
+TInt ConvertToSifErrorCode(TInt aSwiErrorCode)
+ {
+ if (aSwiErrorCode > KSystemWideErrorsBoundary)
+ return aSwiErrorCode;
+ switch (aSwiErrorCode)
+ {
+ case KErrSISFieldIdMissing:
+ case KErrSISFieldLengthMissing:
+ case KErrSISFieldLengthInvalid:
+ case KErrSISStringInvalidLength:
+ case KErrSISSignedControllerSISControllerMissing:
+ case KErrSISControllerSISInfoMissing:
+ case KErrSISInfoSISUidMissing:
+ case KErrSISInfoSISNamesMissing:
+ case KErrSISFieldBufferTooShort:
+ case KErrSISStringArrayInvalidElement:
+ case KErrSISInfoSISVendorNamesMissing:
+ case KErrSISInfoSISVersionMissing:
+ case KErrSISControllerSISSupportedLanguagesMissing:
+ case KErrSISSupportedLanguagesInvalidElement:
+ case KErrSISLanguageInvalidLength:
+ case KErrSISContentsSISSignedControllerMissing:
+ case KErrSISContentsSISDataMissing:
+ case KErrSISDataSISFileDataUnitMissing:
+ case KErrSISFileDataUnitTargetMissing:
+ case KErrSISFileOptionsMissing:
+ case KErrSISFileDataUnitDescriptorMissing:
+ case KErrSISFileDataDescriptionMissing:
+ case KErrSISContentsMissing:
+ case KErrSISEmbeddedControllersMissing:
+ case KErrSISEmbeddedDataUnitsMissing:
+ case KErrSISControllerOptionsMissing:
+ case KErrSISExpressionMissing:
+ case KErrSISExpressionStringValueMissing:
+ case KErrSISOptionsStringMissing:
+ case KErrSISFileOptionsExpressionMissing:
+ case KErrSISExpressionHeadValueMissing:
+ case KErrSISEmbeddedSISOptionsMissing:
+ case KErrSISInfoSISUpgradeRangeMissing:
+ case KErrSISDependencyMissingUid:
+ case KErrSISDependencyMissingVersion:
+ case KErrSISDependencyMissingNames:
+ case KErrSISControllerMissingPrerequisites:
+ case KErrSISUpgradeRangeMissingVersion:
+ case KErrSISUnexpectedFieldType:
+ case KErrSISExpressionUnknownOperator:
+ case KErrSISArrayReadError:
+ case KErrSISArrayTypeMismatch:
+ case KErrSISInvalidStringLength:
+ case KErrSISCompressionNotSupported:
+ case KErrSISTooDeeplyEmbedded:
+ case KErrWrongHeaderFormat:
+ case KErrExpressionToComplex:
+ case KErrInvalidExpression:
+ case KErrInvalidType:
+
+ return KErrSifCorruptedPackage;
+
+ case KErrBadUsage:
+ case KErrInstallerLeave:
+
+ return KErrSifUnknown;
+
+ case KErrSISPrerequisitesMissingDependency:
+
+ return KErrSifMissingDependencies;
+
+ case KErrMissingBasePackage:
+
+ return KErrSifMissingBasePackage;
+
+ case KErrCapabilitiesMismatch:
+ case KErrInvalidEclipsing:
+ case KErrSecurityError:
+ case KErrBadHash:
+ case KErrDigestNotSupported:
+ case KErrSignatureSchemeNotSupported:
+ case KErrSISWouldOverWrite:
+ case KErrSISInvalidTargetFile:
+
+ return KErrPermissionDenied;
+
+ case KErrPolicyFileCorrupt:
+
+ return KErrSifBadInstallerConfiguration;
+
+ case KErrInvalidUpgrade:
+ case KErrLegacySisFile:
+
+ return KErrSifPackageCannotBeInstalledOnThisDevice;
+
+ case KErrSISNotEnoughSpaceToInstall:
+
+ return KErrSifNotEnoughSpace;
+
+ default:
+ return KErrSifUnknown;
+ }
+ }
+
+TBool CRefNativePluginActiveImpl::NeedUserCapabilityL()
+ {
+ // Silent install is not allowed when the package requires additional capabilities
+ // than what it is signed for (Pakage may request for some capability that is not
+ // granted by the certificate used to sign it).
+ for(TInt cap=0; cap<ECapability_Limit; ++cap)
+ {
+ if (iComponentInfo->RootNodeL().UserGrantableCaps().HasCapability(TCapability(cap)))
+ {
+ DEBUG_PRINTF2(_L("Package requires additional capability - %d"), cap);
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+ }
+
+void CRefNativePluginActiveImpl::RunL()
+ {
+ if (iSilentInstall)
+ {
+ DEBUG_PRINTF(_L("Silent install - CRefNativePluginActiveImpl::RunL"));
+ ProcessSilentInstallL();
+ }
+ else
+ {
+ TInt res = iStatus.Int();
+ DEBUG_PRINTF2(_L8("Reference native plugin - Operation finished with result %d"), res);
+
+ // Output options
+ if (iOutputParams != NULL)
+ {
+ iOutputParams->AddIntL(KSifOutParam_ExtendedErrCode, res);
+
+ if (iInstallRequest && res == KErrNone)
+ {
+ TComponentId resultComponentId = 0;
+ TRAPD(getLastIdErr, resultComponentId = GetLastInstalledComponentIdL());
+ if (getLastIdErr == KErrNone)
+ iOutputParams->AddIntL(KSifOutParam_ComponentId, resultComponentId);
+ }
+ }
+
+ User::RequestComplete(iClientStatus, ConvertToSifErrorCode(res));
+ iClientStatus = NULL;
+ }
+ }
+
+void CRefNativePluginActiveImpl::ProcessSilentInstallL()
+ {
+ // We need to do this only once per installation request
+ iSilentInstall = EFalse;
+ iInstallRequest = ETrue;
+
+ TBool isNotAuthenticated = (ENotAuthenticated == iComponentInfo->RootNodeL().Authenticity());
+ TBool reqUserCap = NeedUserCapabilityL();
+ if (isNotAuthenticated || reqUserCap)
+ {
+ if (isNotAuthenticated)
+ {
+ DEBUG_PRINTF(_L("Silent Install is not allowed on unsigned or self-signed packages"));
+ }
+
+ if (reqUserCap)
+ {
+ DEBUG_PRINTF(_L("Silent Install is not allowed when user capabilities are required"));
+ }
+
+ User::RequestComplete(iClientStatus, KErrNotSupported);
+ iClientStatus = NULL;
+ }
+ else
+ {
+ TInt err;
+ if (iFileHandle)
+ {
+ TRAP(err, iAsyncLauncher->InstallL(*this, *iFileHandle, *iInstallPrefs, iStatus));
+ }
+ else
+ {
+ //DEBUG_PRINTF2(_L("!!!Silent install for %S"), iFileName);
+ TRAP(err, iAsyncLauncher->InstallL(*this, iFileName, *iInstallPrefs, iStatus));
+ }
+
+ if (err != KErrNone)
+ {
+ User::RequestComplete(iClientStatus, err);
+ iClientStatus = NULL;
+ }
+
+ SetActive();
+ }
+ }
+
+void CRefNativePluginActiveImpl::DoCancel()
+ {
+ if (iClientStatus)
+ {
+ iAsyncLauncher->CancelOperation();
+ delete iAsyncLauncher;
+ iAsyncLauncher = NULL;
+
+ User::RequestComplete(iClientStatus, KErrCancel);
+ iClientStatus = NULL;
+ }
+ }
+
+void CRefNativePluginActiveImpl::CommonRequestPreamble(const TSecurityContext& aSecurityContext, const COpaqueNamedParams& aInputParams,
+ COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)
+ {
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ iInputParams = &aInputParams;
+ iOutputParams = &aOutputParams;
+
+ TInt declineOperation = 0;
+ TRAPD(err, aInputParams.GetIntByNameL(KDeclineOperationOptionName, declineOperation));
+ if(err == KErrNone && declineOperation)
+ {
+ iDeclineOperation = ETrue;
+ }
+
+ // Check to see if we have the opaque input argument - InstallSilently
+ TInt silentInstall = 0;
+ TRAP_IGNORE(aInputParams.GetIntByNameL(KSifInParam_InstallSilently, silentInstall));
+ if (silentInstall)
+ {
+ iSilentInstall = ETrue;
+ if (!aSecurityContext.HasCapability(ECapabilityTrustedUI))
+ {
+ User::RequestComplete(iClientStatus, KErrPermissionDenied);
+ iClientStatus = NULL;
+ }
+ }
+ }
+
+TComponentId CRefNativePluginActiveImpl::GetLastInstalledComponentIdL()
+ {
+ ASSERT(iInstallRequest);
+
+ // Find the id of the last installed component and return it
+ TInt uid;
+ User::LeaveIfError(RProperty::Get(KUidSystemCategory, KUidSwiLatestInstallation, uid));
+
+ Swi::RSisRegistrySession sisRegistrySession;
+ User::LeaveIfError(sisRegistrySession.Connect());
+ CleanupClosePushL(sisRegistrySession);
+
+ TUid tuid(TUid::Uid(uid));
+ TComponentId componentId = sisRegistrySession.GetComponentIdForUidL(tuid);
+ CleanupStack::PopAndDestroy(&sisRegistrySession);
+
+ return componentId;
+ }
+
+void CRefNativePluginActiveImpl::GetComponentInfo(const TDesC& aFileName, CComponentInfo& aComponentInfo, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF2(_L("Reference native plugin - retrieving component info for %S"), &aFileName);
+
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ TRAPD(err, iAsyncLauncher->GetComponentInfoL(*this, aFileName, *iInstallPrefs, aComponentInfo, iStatus));
+ if (err != KErrNone)
+ {
+ TRequestStatus *statusPtr(&aStatus);
+ User::RequestComplete(statusPtr, err);
+ return;
+ }
+
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::GetComponentInfo(RFile& aFileHandle, CComponentInfo& aComponentInfo, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - getting component info by file handle"));
+
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ TRAPD(err, iAsyncLauncher->GetComponentInfoL(*this, aFileHandle, *iInstallPrefs, aComponentInfo, iStatus));
+ if (err != KErrNone)
+ {
+ TRequestStatus *statusPtr(&aStatus);
+ User::RequestComplete(statusPtr, err);
+ return;
+ }
+
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::Install(const TDesC& aFileName, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,
+ TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF2(_L("Reference native plugin - install for %S"), &aFileName);
+
+ CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);
+
+ TInt err;
+ if (iSilentInstall)
+ {
+ // Silent install does a few addtional checks on the package to see if is
+ // signed and had the required capabilities. So we need to the get the
+ // package component information with out installing it.
+ DEBUG_PRINTF2(_L("Silent install - Get the ComponentInfo for %S"), &aFileName);
+ iFileName = aFileName;
+ TRAP(err, iAsyncLauncher->GetComponentInfoL(*this, aFileName, *iInstallPrefs, *iComponentInfo, iStatus));
+ }
+ else
+ {
+ // Proceed with the normal installation.
+ TRAP(err, iAsyncLauncher->InstallL(*this, aFileName, *iInstallPrefs, iStatus));
+ iInstallRequest = ETrue;
+ }
+
+ if (err != KErrNone)
+ {
+ TRequestStatus *statusPtr(&aStatus);
+ User::RequestComplete(statusPtr, err);
+ return;
+ }
+
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::Install(RFile& aFileHandle, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams,
+ TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - install by file handle"));
+
+ CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);
+
+ TInt err;
+ if (iSilentInstall)
+ {
+ // Silent install does a few addtional checks on the package to see if is
+ // signed and had the required capabilities. So we need to the get the
+ // package component information with out installing it.
+ iFileHandle = &aFileHandle;
+ TRAP(err, iAsyncLauncher->GetComponentInfoL(*this, aFileHandle, *iInstallPrefs, *iComponentInfo, iStatus));
+ }
+ else
+ {
+ // Proceed with the normal installation.
+ TRAP(err, iAsyncLauncher->InstallL(*this, aFileHandle, *iInstallPrefs, iStatus));
+ iInstallRequest = ETrue;
+ }
+
+ if (err != KErrNone)
+ {
+ TRequestStatus *statusPtr(&aStatus);
+ User::RequestComplete(statusPtr, err);
+ return;
+ }
+
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::Uninstall(TComponentId aComponentId, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)
+ {
+ TRAPD(err, UninstallL(aComponentId, aSecurityContext, aInputParams, aOutputParams, aStatus));
+ if (err != KErrNone)
+ {
+ TRequestStatus *statusPtr(&aStatus);
+ User::RequestComplete(statusPtr, err);
+ return;
+ }
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::UninstallL(TComponentId aComponentId, const TSecurityContext& aSecurityContext,
+ const COpaqueNamedParams& aInputParams, COpaqueNamedParams& aOutputParams, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - uninstall"));
+ CommonRequestPreamble(aSecurityContext, aInputParams, aOutputParams, aStatus);
+ // Get UID for given component id
+ RSoftwareComponentRegistry scrSession;
+ User::LeaveIfError(scrSession.Connect());
+ CleanupClosePushL(scrSession);
+
+ CPropertyEntry* propertyEntry = scrSession.GetComponentPropertyL(aComponentId, _L("CompUid"));
+ CleanupStack::PushL(propertyEntry);
+
+ CIntPropertyEntry* intPropertyEntry = dynamic_cast<CIntPropertyEntry *>(propertyEntry);
+
+ TRequestStatus *statusPtr(&aStatus);
+ if (intPropertyEntry == NULL)
+ {
+ DEBUG_PRINTF2(_L8("UID property for component %d was not found"), aComponentId);
+ User::RequestComplete(statusPtr, KErrNotFound);
+ return;
+ }
+
+ TUid objectId = TUid::Uid(intPropertyEntry->IntValue());
+ CleanupStack::PopAndDestroy(2, &scrSession);
+
+ iAsyncLauncher->UninstallL(*this, objectId, iStatus);
+ }
+
+void CRefNativePluginActiveImpl::Activate(TComponentId aComponentId, const TSecurityContext& /*aSecurityContext*/, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - activate"));
+ iStatus = KRequestPending;
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ TRequestStatus* rs(&iStatus);
+
+ Swi::RSisRegistryWritableSession sisRegSession;
+ TRAPD(err,
+ User::LeaveIfError(sisRegSession.Connect());
+ sisRegSession.ActivateComponentL(aComponentId);
+ )
+ sisRegSession.Close();
+
+ User::RequestComplete(rs, err);
+ SetActive();
+ }
+
+void CRefNativePluginActiveImpl::Deactivate(TComponentId aComponentId, const TSecurityContext& /*aSecurityContext*/, TRequestStatus& aStatus)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - deactivate"));
+ iStatus = KRequestPending;
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ TRequestStatus* rs(&iStatus);
+
+ Swi::RSisRegistryWritableSession sisRegSession;
+ TRAPD(err,
+ User::LeaveIfError(sisRegSession.Connect());
+ sisRegSession.DeactivateComponentL(aComponentId);
+ )
+ sisRegSession.Close();
+
+ User::RequestComplete(rs, err);
+ SetActive();
+ }
+
+// SWI::MUiHandler implementation
+TInt CRefNativePluginActiveImpl::DisplayLanguageL(const Swi::CAppInfo& /*aAppInfo*/,const RArray<TLanguage>& /*aLanguages*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayLanguageL"));
+ return 0;
+ }
+
+TInt CRefNativePluginActiveImpl::DisplayDriveL(const Swi::CAppInfo& /*aAppInfo*/,TInt64 /*aSize*/, const RArray<TChar>& /*aDriveLetters*/, const RArray<TInt64>& /*aDriveSpaces*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayDriveL"));
+ return 0;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayUninstallL(const Swi::CAppInfo& /*aAppInfo*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayUninstallL"));
+ if (iDeclineOperation)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Received an option to decline operation - stopping uninstall"));
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayTextL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TFileTextOption /*aOption*/, const TDesC& /*aText*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayTextL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayDependencyBreakL(const Swi::CAppInfo& /*aAppInfo*/, const RPointerArray<TDesC>& /*aComponents*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayDependencyBreakL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayApplicationsInUseL(const Swi::CAppInfo& /*aAppInfo*/, const RPointerArray<TDesC>& /*aAppNames*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayApplicationsInUseL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayQuestionL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TQuestionDialog /*aQuestion*/, const TDesC& /*aDes*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayQuestionL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayInstallL(const Swi::CAppInfo& /*aAppInfo*/, const CApaMaskedBitmap* /*aLogo*/, const RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayInstallL"));
+
+ if (iDeclineOperation)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - Received an option to decline operation - stopping install"));
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayGrantCapabilitiesL(const Swi::CAppInfo& /*aAppInfo*/, const TCapabilitySet& /*aCapabilitySet*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayGrantCapabilitiesL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayUpgradeL(const Swi::CAppInfo& /*aAppInfo*/, const Swi::CAppInfo& /*aExistingAppInfo*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayUpgradeL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayOptionsL(const Swi::CAppInfo& /*aAppInfo*/, const RPointerArray<TDesC>& /*aOptions*/, RArray<TBool>& /*aSelections*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayOptionsL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplaySecurityWarningL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TSignatureValidationResult /*aSigValidationResult*/,
+ RPointerArray<CPKIXValidationResultBase>& /*aPkixResults*/, RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/, TBool /*aInstallAnyway*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplaySecurityWarningL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayOcspResultL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TRevocationDialogMessage /*aMessage*/, RPointerArray<TOCSPOutcome>& /*aOutcomes*/,
+ RPointerArray<Swi::CCertificateInfo>& /*aCertificates*/,TBool /*aWarningOnly*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayOcspResultL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::DisplayMissingDependencyL(const Swi::CAppInfo& /*aAppInfo*/, const TDesC& /*aDependencyName*/, TVersion /*aWantedVersionFrom*/,
+ TVersion /*aWantedVersionTo*/, TVersion /*aInstalledVersion*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayMissingDependencyL"));
+ return ETrue;
+ }
+
+TBool CRefNativePluginActiveImpl::HandleInstallEventL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TInstallEvent /*aEvent*/, TInt /*aValue*/, const TDesC& /*aDes*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - HandleInstallEventL"));
+ return ETrue;
+ }
+
+void CRefNativePluginActiveImpl::HandleCancellableInstallEventL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TInstallCancellableEvent /*aEvent*/, Swi::MCancelHandler& /*aCancelHandler*/,
+ TInt /*aValue*/,const TDesC& /*aDes*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - HandleCancellableInstallEventL"));
+ }
+
+void CRefNativePluginActiveImpl::DisplayCannotOverwriteFileL(const Swi::CAppInfo& /*aAppInfo*/, const Swi::CAppInfo& /*aInstalledAppInfo*/,const TDesC& /*aFileName*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayCannotOverwriteFileL"));
+ }
+
+void CRefNativePluginActiveImpl::DisplayErrorL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TErrorDialog /*aType*/, const TDesC& /*aParam*/)
+ {
+ DEBUG_PRINTF(_L8("Reference native plugin - DisplayErrorL"));
+ }
+