diff -r 5cc91383ab1e -r 7333d7932ef7 installationservices/swinstallationfw/examples/refnativeplugin/source/refnativeplugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/installationservices/swinstallationfw/examples/refnativeplugin/source/refnativeplugin.cpp Tue Aug 31 15:21:33 2010 +0300 @@ -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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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; capRootNodeL().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(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& /*aLanguages*/) + { + DEBUG_PRINTF(_L8("Reference native plugin - DisplayLanguageL")); + return 0; + } + +TInt CRefNativePluginActiveImpl::DisplayDriveL(const Swi::CAppInfo& /*aAppInfo*/,TInt64 /*aSize*/, const RArray& /*aDriveLetters*/, const RArray& /*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& /*aComponents*/) + { + DEBUG_PRINTF(_L8("Reference native plugin - DisplayDependencyBreakL")); + return ETrue; + } + +TBool CRefNativePluginActiveImpl::DisplayApplicationsInUseL(const Swi::CAppInfo& /*aAppInfo*/, const RPointerArray& /*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& /*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& /*aOptions*/, RArray& /*aSelections*/) + { + DEBUG_PRINTF(_L8("Reference native plugin - DisplayOptionsL")); + return ETrue; + } + +TBool CRefNativePluginActiveImpl::DisplaySecurityWarningL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TSignatureValidationResult /*aSigValidationResult*/, + RPointerArray& /*aPkixResults*/, RPointerArray& /*aCertificates*/, TBool /*aInstallAnyway*/) + { + DEBUG_PRINTF(_L8("Reference native plugin - DisplaySecurityWarningL")); + return ETrue; + } + +TBool CRefNativePluginActiveImpl::DisplayOcspResultL(const Swi::CAppInfo& /*aAppInfo*/, Swi::TRevocationDialogMessage /*aMessage*/, RPointerArray& /*aOutcomes*/, + RPointerArray& /*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")); + } +