diff -r 000000000000 -r 3ce708148e4d applicationmanagement/server/src/AMDeploymentComponent.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applicationmanagement/server/src/AMDeploymentComponent.cpp Thu Dec 17 08:40:12 2009 +0200 @@ -0,0 +1,830 @@ +/* + * Copyright (c) 2005 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: Implementation of applicationmanagement components + * + */ + +#include "AMDownload.h" +#include "AMDeploymentComponent.h" +#include "debug.h" +#include +#include +#include +#include "amprivateCRKeys.h" +//#include "aminstalloptions.h" +#include +#ifdef __SERIES60_30__ +#include +#endif +#include "amsmlhelper.h" + +using namespace NApplicationManagement; + +_LIT8( KAMDCDataSuffix, "_D.txt"); +_LIT8( KAMDCMetaDataSuffix, "_M.txt"); + + +/*************************************************** + // CDeploymentComponent + ***************************************************/ + +CDeploymentComponent* CDeploymentComponent::NewLC(TInt aInternalId, + const TDCUserId &aUserId) + { + CDeploymentComponent *self = new ( ELeave ) CDeploymentComponent( aInternalId ); + CleanupStack::PushL(self) ; + self->ConstructL(aUserId) ; + return self; + } + +CDeploymentComponent* CDeploymentComponent::NewL(TInt aInternalId, + const TDCUserId &aUserId) + { + CDeploymentComponent *self = NewLC(aInternalId, aUserId); + CleanupStack::Pop(self) ; + return self; + } + +CDeploymentComponent* CDeploymentComponent::LoadLC(TInt aInternalId, + const TDesC8 &aBuffer) + { + CDeploymentComponent *self = new ( ELeave ) CDeploymentComponent(aInternalId); + CleanupStack::PushL(self) ; + self->ConstructLoadL(aBuffer) ; + return self; + } + +CDeploymentComponent* CDeploymentComponent::LoadL(TInt aInternalId, + const TDesC8 &aBuffer) + { + CDeploymentComponent *self = LoadLC(aInternalId, aBuffer); + CleanupStack::Pop(self) ; + return self; + } + +CDeploymentComponent::CDeploymentComponent(TInt aInternalId) : +iInternalId(aInternalId), iPkgVersion( 3), iOwner( -1), +iOwnerProfile( -1) + { + iUninstallOpts.iKillApp = SwiUI::EPolicyAllowed; + SwiUI::TInstallOptions &opts = iInstallOpts.iOptions; + opts.iUpgrade = SwiUI::EPolicyNotAllowed; + opts.iOptionalItems = SwiUI::EPolicyNotAllowed; + opts.iOCSP = SwiUI::EPolicyNotAllowed; + opts.iIgnoreOCSPWarnings = SwiUI::EPolicyNotAllowed; + // iIgnoreOtherWarnings = SwiUI::EPolicyNotAllowed; + opts.iUntrusted = SwiUI::EPolicyNotAllowed; + opts.iPackageInfo = SwiUI::EPolicyNotAllowed; + opts.iCapabilities = SwiUI::EPolicyNotAllowed; + opts.iKillApp = SwiUI::EPolicyNotAllowed; + opts.iOverwrite = SwiUI::EPolicyNotAllowed; + opts.iDownload = SwiUI::EPolicyNotAllowed; + opts.iDrive = SwiUI::EPolicyNotAllowed; + opts.iLang = ELangNone; + opts.iUsePhoneLang = EFalse; + } + +CDeploymentComponent::~CDeploymentComponent() + { + RDEBUG8_3( "CDeploymentComponent::~CDeploymentComponent 0x%X - 0x%X", + reinterpret_cast(this), reinterpret_cast(this)+sizeof( CDeploymentComponent ) ); + delete iData; + iData = NULL; + + delete iMetaData; + iMetaData = NULL; + } + +CDeploymentComponent &CDeploymentComponent::operator=( const CDeploymentComponent &aData ) + { + if( &aData != this ) + { + *iData = aData.Data(); + *iMetaData = aData.MetaData(); + iId = aData.ComponentId(); + iName = aData.ComponentName(); + iVersion = aData.iVersion; + iState = aData.State(); + iInternalId = aData.InternalId(); + iUid = aData.Uid(); + iUserId = aData.iUserId; + iOwner = aData.iOwner; + iInstallOpts = aData.InstallOpts(); + iPkgID = aData.PkgId(); + iDescription = aData.Description(); + iPkgIDRef = aData.PkgIDRef(); + iPkgType = aData.PkgType(); + iRemovableApp = aData.AppRemovable(); + iInstallOptsSet = aData.InstallOptsSet(); + iPkgVersion = aData.iPkgVersion; + iDownloadStatus = aData.iDownloadStatus; + iDownloadURI = aData.iDownloadURI; + iUninstallOpts = aData.UninstallOpts(); + iOwnerProfile = aData.OwnerProfile(); + } + return *this; + } + +void CDeploymentComponent::PersistL(CRepository &aRepository) const + { + CBufBase *buf = CBufFlat::NewL( 32); + CleanupStack::PushL(buf); + TInt length(SerializedFormLength() ); + buf->ExpandL(0, length+1); + TPtr8 p3(buf->Ptr(0) ); + RDesWriteStream stream(p3); + TInt len(SerializedFormL(stream) ); + TBuf8< NCentralRepositoryConstants::KMaxBinaryLength> tbuf; + + TInt err(aRepository.Get(iInternalId, tbuf) ); + if (err == KErrNotFound) + { + err = aRepository.Create(iInternalId, buf->Ptr(0) ); + RDEBUG_3( "CDeploymentComponent::PersistL: Created %d to centrep with status %d", iInternalId, err ); + } + else + { + User::LeaveIfError(err) ; + err = aRepository.Set(iInternalId, buf->Ptr(0) ); + RDEBUG_3( "CDeploymentComponent::PersistL: Persisted %d to centrep with status %d", iInternalId, err ); + } + User::LeaveIfError(err) ; + CleanupStack::PopAndDestroy(buf); + RFs fs; + User::LeaveIfError(fs.Connect() ); + CleanupClosePushL(fs); + iData->PersistL(fs); + iMetaData->PersistL(fs); + CleanupStack::PopAndDestroy( &fs) ; + } + +void CDeploymentComponent::CopyStateTo(TDeploymentComponent &aInfo) const + { + aInfo.iId = iId; + aInfo.iName = iName; + aInfo.iVersion = iVersion; + aInfo.iDescription = iDescription; + aInfo.iPkgID = iPkgID; + aInfo.iPkgIDRef = iPkgIDRef; + aInfo.iPkgType = iPkgType; + aInfo.iState = iState; + aInfo.iOldState = iOldState; + } + +TBool CDeploymentComponent::IsJavaMimeL(const TDesC8& aMime) + { + + FeatureManager::InitializeLibL(); + TBool supported = EFalse; + + if (FeatureManager::FeatureSupported(KFeatureIdJavaMIDP20) ) + { + supported = ((aMime == SwiUI::KJarMIMEType || aMime + == SwiUI::KJadMIMEType || aMime == SwiUI::KJarxMIMEType + || aMime == SwiUI::KJavaMIMEType) ? ETrue : EFalse ); + } + FeatureManager::UnInitializeLib(); + + return supported; + } + +TBool CDeploymentComponent::IsSisMimeL(const TDesC8& aMime) + { + + + TBool supported = EFalse; + + supported = ((aMime == SwiUI::KSisxMimeType || aMime + == SwiUI::KSisMimeType || aMime == SwiUI::KPipMimeType) ? ETrue : EFalse ); + + return supported; + } + +void CDeploymentComponent::ConstructL(const TDCUserId &aUserId) + { + iUserId = aUserId; + RFs fs; + User::LeaveIfError(fs.Connect() ); + CleanupClosePushL(fs); + TInt e(fs.CreatePrivatePath(KDefaultDrive) ); + User::LeaveIfError(e); + TBuf<30> privatePath; + fs.PrivatePath(privatePath); + CleanupStack::PopAndDestroy( &fs); + + TInt privPathLength(privatePath.Length() ); + TBuf8<10> buf; + buf.NumFixedWidth(iInternalId, EHex, 10); + + TBuf8 <30> path; + path.Copy(privatePath); + HBufC8 *afilename = HBufC8::NewLC(privPathLength + 10 + KAMDCDataSuffix().Length()); + *afilename = path; + TPtr8 afn(afilename->Des() ); + afn.Append(buf); + afn.Append(KAMDCDataSuffix) ; + iData = CDeploymentComponentData::NewL(CDeploymentComponentData::EData, + KNullDesC8, KNullDesC8, afn); + + afn.Replace(privPathLength + 10, KAMDCMetaDataSuffix().Length(), KAMDCMetaDataSuffix); + iMetaData = CDeploymentComponentData::NewL( + CDeploymentComponentData::EMetaData, KNullDesC8, KNullDesC8, afn); + + CleanupStack::PopAndDestroy(afilename); + } + +TInt CDeploymentComponent::SerializedFormLength() const + { + // 0 1 2 3 4 5 6 7 8 9 10 11 + // iUserId , iState, iPkgVer, iUid, iIdLen, iNameLen, iVersLen, iDownState, iOwner, iOldState ,iDownUriLen, iInstallOptsset + return (20*4)+iUserId.Length() + iId.Length() + iName.Length() + + iVersion.Length() + + + iMidletName.Length() + iMideltVendorName.Length() + + iMidletVersion.Length()+ iDownloadURI.Length() + + iDescription.Length()+ iPkgID.Length()+iPkgIDRef.Length() + +iPkgType.Length()+ sizeof(iRemovableApp) + iData->SerializedFormLength() + + iMetaData->SerializedFormLength() + sizeof(TAMInstallOptions); + } + +TInt CDeploymentComponent::SerializedFormL(RWriteStream &aBuffer) const + { +#ifdef _DEBUG + RDEBUG_2( "Offset before uint: %d", aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset() ); +#endif + + aBuffer.WriteUint32L(iPkgVersion); + +#ifdef _DEBUG + RDEBUG_2( "Offset after uint: %d" , aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset() ); +#endif + + aBuffer.WriteUint32L(iState); + aBuffer.WriteUint32L(iStatus); + aBuffer.WriteUint32L(iUid.iUid); + aBuffer.WriteUint32L(iUserId.Length() ); + aBuffer.WriteL(iUserId); + aBuffer.WriteUint32L(iId.Length() ); + aBuffer.WriteL(iId); + aBuffer.WriteUint32L(iName.Length() ); + aBuffer.WriteL(iName); + aBuffer.WriteUint32L(iVersion.Length() ); + aBuffer.WriteL(iVersion); + aBuffer.WriteUint32L(iMidletName.Length() ); + aBuffer.WriteL(iMidletName); + aBuffer.WriteUint32L(iMideltVendorName.Length() ); + aBuffer.WriteL(iMideltVendorName); + aBuffer.WriteUint32L(iMidletVersion.Length() ); + aBuffer.WriteL(iMidletVersion); + aBuffer.WriteInt32L(iDownloadStatus); + aBuffer.WriteInt32L(iOwner); + aBuffer.WriteUint32L(iOldState); + aBuffer.WriteUint32L(iDownloadURI.Length() ); + aBuffer.WriteL(iDownloadURI); + aBuffer.WriteUint32L(iDescription.Length() ); + aBuffer.WriteL(iDescription); + aBuffer.WriteUint32L(iPkgID.Length() ); + aBuffer.WriteL(iPkgID); + aBuffer.WriteUint32L(iPkgIDRef.Length() ); + aBuffer.WriteL(iPkgIDRef); + aBuffer.WriteUint32L(iPkgType.Length() ); + aBuffer.WriteL(iPkgType); + aBuffer.WriteUint32L(iRemovableApp); + iData->SerializedFormL(aBuffer); + iMetaData->SerializedFormL(aBuffer); + aBuffer.WriteUint32L(iInstallOptsSet); + TPckg opts(iInstallOpts); + aBuffer.WriteL(opts); + return aBuffer.Sink()->TellL( MStreamBuf::EWrite ).Offset(); + } + +void CDeploymentComponent::ConstructLoadL(const TDesC8 &aBuffer) + { + RDEBUG( "CDeploymentComponent::ConstructLoadL "); + TDeploymentComponent aRes; + TMimeType aType; + + RDesReadStream stream(aBuffer); + iPkgVersion = stream.ReadUint32L(); + + iState = static_cast(stream.ReadUint32L() ); + iStatus = static_cast(stream.ReadUint32L() ); + iUid.iUid = stream.ReadUint32L(); + + TUint32 len(stream.ReadUint32L() ); + stream.ReadL(iUserId, len); + + len = stream.ReadUint32L(); + stream.ReadL(iId, len); + + len = stream.ReadUint32L(); + stream.ReadL(iName, len); + + len = stream.ReadUint32L(); + stream.ReadL(iVersion, len); + + len = stream.ReadUint32L(); + stream.ReadL(iMidletName, len); + + len = stream.ReadUint32L(); + stream.ReadL(iMideltVendorName, len); + + len = stream.ReadUint32L(); + stream.ReadL(iMidletVersion, len); + + iDownloadStatus = stream.ReadInt32L(); + + if (iPkgVersion > 1) + { + iOwner = stream.ReadInt32L(); + } + if (iPkgVersion > 2) + { + iOldState = TDeploymentComponentState(stream.ReadUint32L() ); + } + + len = stream.ReadUint32L() ; + stream.ReadL(iDownloadURI, len); + + len = stream.ReadUint32L(); + stream.ReadL(iDescription, len); + + len = stream.ReadUint32L(); + stream.ReadL(iPkgID, len); + + len = stream.ReadUint32L(); + stream.ReadL(iPkgIDRef, len); + + len = stream.ReadUint32L(); + stream.ReadL(iPkgType, len); + + iRemovableApp = stream.ReadUint32L(); + iData = CDeploymentComponentData::LoadL(stream); + iMetaData = CDeploymentComponentData::LoadL(stream); + + //using namespace SwiUI; + iInstallOptsSet = stream.ReadUint32L(); + TAMInstallOptionsPckg opts(iInstallOpts); + stream.ReadL(opts, opts.Length() ); + RDEBUG( "CDeploymentComponent::ConstructLoadL end"); + } + +CDeploymentComponentData &CDeploymentComponent::Data() + { + return *iData; + } + +const CDeploymentComponentData &CDeploymentComponent::Data() const + { + return *iData; + } + +CDeploymentComponentData &CDeploymentComponent::MetaData() + { + return *iMetaData; + } + +const CDeploymentComponentData &CDeploymentComponent::MetaData() const + { + return *iMetaData; + } + +const TAMInstallOptions &CDeploymentComponent::InstallOpts() const + { + return iInstallOpts; + } + +const SwiUI::TUninstallOptions &CDeploymentComponent::UninstallOpts() const + { + return iUninstallOpts; + } + +TBool CDeploymentComponent::InstallOptsSet() const + { + return iInstallOptsSet; + } + +TBool CDeploymentComponent::AppRemovable() const + { + return iRemovableApp; + } + +void CDeploymentComponent::SetMetaDataL(const TDesC8 &aMimeType) + { + iMetaData->DataFileName(); + iMetaData->SetDataL(aMimeType); + } + +void CDeploymentComponent::SetMetaDataL(const TDesC8 &aMetaData, + const TDesC8 &aMimeType) + { + iMetaData->SetDataL(aMetaData, aMimeType); + } + +void CDeploymentComponent::SetAppRemovableStatus(const TBool &aRemovable) + { + iRemovableApp = aRemovable; + } + +void CDeploymentComponent::SetInstallOptsL(const TDesC8 &aInstallOpts) + { + using namespace SwiUI; + if (aInstallOpts != KNullDesC8) + { + RDEBUG8_2( "CDeploymentComponent::SetInstallOptsL: '%S'", &aInstallOpts ); + TInt tmpIAP(iInstallOpts.iIAP); + TAMInstallOptionsPckg pckg(iInstallOpts); + pckg.Copy(aInstallOpts); + iInstallOptsSet= ETrue; + + if (iInstallOpts.iIAP == -1 && tmpIAP > -1) + { + RDEBUG8_2( "CDeploymentComponent::SetInstallOptsL: using IAPid %d", tmpIAP ); + iInstallOpts.iIAP = tmpIAP; + } + } + + } + +void CDeploymentComponent::ResetDataL(RFs &aFs) + { + iData->ResetData(aFs); + iMetaData->ResetData(aFs); + } + +void CDeploymentComponent::SetAttr(TDes8 &aAttr, const TDesC8 &aNewVal) const + { + if (aNewVal.Length() > aAttr.MaxLength() ) + { + aAttr = aNewVal.Left(aAttr.MaxLength() ); + } + else + { + aAttr = aNewVal; + } + } + +void CDeploymentComponent::SetIdL(const TDesC8 &aId) + { + SetAttr(iId, aId); + } + +void CDeploymentComponent::SetNameL(const TDesC8 &aName) + { + if (iName != aName) + { + SetAttr(iName, aName); + } + } + +void CDeploymentComponent::SetVersionL(const TDesC8 &aVersion) + { + SetAttr(iVersion, aVersion); + } +void CDeploymentComponent::SetMimeTypeL( const TDesC8 &aMimeType ) +{ + iData->SetMimeTypeL(aMimeType); +} + +void CDeploymentComponent::SetDescriptionL(const TDesC8 &aDescription) + { + SetAttr(iDescription, aDescription); + } + +void CDeploymentComponent::SetPkgIDL(const TDesC8 &aPkgID) + { + // PkgID and PkgIDRef should be same and Get done on PkgID + // when state is in Download or Delivered and PkgIDRef is + // returned when state is in Deployed state + SetAttr(iPkgID, aPkgID); + SetAttr(iPkgIDRef, aPkgID); + } + +void CDeploymentComponent::SetPkgTypeL(const TDesC8 &aPkgType) + { + + SetAttr(iPkgType, aPkgType); + + } +void CDeploymentComponent::SetMidletNameL(const TDesC8 &aMidletName) + { + SetAttr(iMidletName, aMidletName); + } + +void CDeploymentComponent::SetMidletVendorL(const TDesC8 &aMidletVendor) + { + SetAttr(iMideltVendorName, aMidletVendor); + } + +void CDeploymentComponent::SetMidletVersionL(const TDesC8 &aMidletVersion) + { + SetAttr(iMidletVersion, aMidletVersion); + } + +void CDeploymentComponent::SetUid(const TUid aUid) + { + RDEBUG8_2("CDeploymentComponent::SetUid 0x%x", aUid.iUid ); + iUid = aUid; + iId.Zero(); + if (iUid != TUid::Null() ) + { + iId.AppendNumFixedWidth(iUid.iUid, EHex, 8); + } + } + +void CDeploymentComponent::SetOwnerProfile(TSmlProfileId aOwnerProfile) + { + iOwnerProfile = aOwnerProfile; + } + +TInt CDeploymentComponent::SetState(const TDeploymentComponentState &aState) + { + RDEBUG_2( "CDeploymentComponent::SetState - set to state (%d)", aState ); + + TInt ret(KErrNone); + iOldState = iState; + iState = aState; +#ifdef __SERIES60_30__ + if( iState != iOldState && iState != EDCSDownload && iState != EDCSDelivered ) + { + if ( iUid != TUid::Null() ) + { + RMenuServSession ses; + TBool visible( EFalse ); + if ( iState == EDCSActive ) + { + visible = ETrue; + } + TRAP( ret, ses.SetApplicationVisibilityL( iUid.iUid, visible ) ); + if (ret != KErrNone ) + { + RDEBUG_2( "CDeploymentComponent::SetState - failed to set visiblity %d", ret ); + } + else + { + RDEBUG_2( "CDeploymentComponent::SetState - Set visiblity to %d", visible ); + } + } + else + { + RDEBUG( "CDeploymentComponent::SetState - No need to set visibility to null uid" ); + } + + } + else + { + RDEBUG( "CDeploymentComponent::SetState - No need to change visibility " ); + } +#endif + return ret; + } + +void CDeploymentComponent::SetStatusNode( + const TSCOMOStatusNodeStates &aStatus) const + { + iStatus = aStatus; + CRepository *repository=NULL; + + TRAPD( erx, repository = CRepository::NewL ( KCRUidPrivateApplicationManagementKeys ) ) + ; + if (erx!=KErrNone) + return; + + TRAPD(err, PersistL(*repository)) + ; + + delete repository; + + if (err!=KErrNone) + return; + + } + +void CDeploymentComponent::Set(const TDeploymentComponent &aInfo) + { + iId = aInfo.iId; + iName = aInfo.iId; + iVersion = aInfo.iVersion; + iDescription = aInfo.iDescription; + iPkgID = aInfo.iPkgID; + iPkgIDRef = aInfo.iPkgIDRef; + iPkgType = aInfo.iPkgType; + } + +void CDeploymentComponent::SetDownloadURIL(const TDesC8 &aURI) + { + if (iState == EDCSDownload) + { + iDownloadURI = aURI; + } + else + { + RDEBUG_2( "CDeploymentComponent::SetDownloadURIL: ERROR Illegal state: %d", iState ); + User::Leave(KErrNotSupported) ; + } + } + +void CDeploymentComponent::SetDownloadTarget( + const TDownloadTarget& aDownloadTarget) + { + RDEBUG_2("CDeploymentComponent::SetDownloadTarget: (%d)", aDownloadTarget); + iDownloadTarget = aDownloadTarget; + } + +void CDeploymentComponent::SetDataL(const TDesC8 &aData, + const TDesC8 &aMimeType) + { + iUid = iData->SetDataL(aData, aMimeType); + iId.Zero(); + if (iUid != TUid::Null() ) + { + iId.AppendNumFixedWidth(iUid.iUid, EHex, 8); + } + } + +void CDeploymentComponent::SetDataL(const TDesC &aFileName, + const TDesC8 &aMimeType) + { + SetUid(iData->SetDataL(aFileName, aMimeType) ); + } + +void CDeploymentComponent::SetDataL(const TDesC8 &aMimeType) + { + SetUid(iData->SetDataL(aMimeType) ); + } + +// ---------------------------------------------------------------------------------------- +// CDeploymentComponent::StatusUpdateL +// ---------------------------------------------------------------------------------------- +void CDeploymentComponent::StatusUpdateL(TInt aNewStatus) + { + RDEBUG( "CDeploymentComponent::StatusUpdateL : begin"); + RDEBUG_2( "CDeploymentComponent::StatusUpdateL %d", aNewStatus ); + + if (State() == EDCSDownload) + { + iDownloadStatus = aNewStatus; + RDEBUG_2( "CDeploymentComponent::StatusUpdate: Set status to: %d", iDownloadStatus ); + + if (DownloadFailed() ) + { + SetStatusNode(EDownload_DownloadFailed); + RDEBUG8_2( "CDeploymentComponent::StatusUpdate: ERROR Failed to download URI: '%S' ", &iDownloadURI ); + } + + if (iCallback) + { + iCallback->DownloadComplete( this, iDownloadStatus); + } + } + else + { + RDEBUG_2( "CDeploymentComponent::StatusUpdate: ERROR Illegal state: %d", State() ); + } + RDEBUG( "CDeploymentComponent::StatusUpdateL : end"); + } + +// ---------------------------------------------------------------------------------------- +// CDeploymentComponent::SuccessStatusUpdateL +// ---------------------------------------------------------------------------------------- +void CDeploymentComponent::SuccessStatusUpdateL(const TDesC &aDlFileName, + const TDesC8& aDlMimeType) + { + RDEBUG( "CDeploymentComponent::SuccessStatusUpdateL : start"); + SetDataL(aDlFileName, aDlMimeType); + + // Set PkgID same as MiME type of downloaded content + SetPkgTypeL(aDlMimeType); + + CDeploymentComponent* conflict( NULL); + TBool dlOk(ETrue); + if (iUid != TUid::Null() ) + { + __ASSERT_DEBUG( iCallback, User::Invariant() ); + if (iCallback->UidExistsL(iUid, conflict, this) ) + { + } + } + else + { + RDEBUG( "CDeploymentComponent::StatusUpdateL - WARNING cannot detect uid" ); + if (IsJavaMimeL(aDlMimeType) ||IsSisMimeL(aDlMimeType) ) + { + RDEBUG( "CDeploymentComponent::StatusUpdateL - Ignoring prev warning because it's java" ); + } + else + { + dlOk = EFalse; + //The Operation has been rejected because the device does not support this MIME type. + iDownloadStatus = KStatusUnSupportedEnvironment; + } + } + + if (dlOk) + { + /*for Predefined static node, append static node name with Internal ID before + * moving to delivered state to avoid duplicates + */ + TBuf8<256> staticnode; + TInt staticnodeenabled = 0; + CRepository* cenrep = CRepository::NewLC( KCRUidPrivateApplicationManagementKeys ); + cenrep->Get( KAMDownloadPredefinedNode, staticnode ); + cenrep->Get( KAMStaticNodeEnabled, staticnodeenabled ); + CleanupStack::PopAndDestroy(); //cenrep + if (iUserId.Compare(staticnode) == 0 && staticnodeenabled) + { + iUserId.Append(*IntToDes8LC(iInternalId)); + CleanupStack::PopAndDestroy(); // for IntToDes8LC() + } + + //Reset the value of DownloadStatus for success update + iDownloadStatus = 0; + + SetState(EDCSDelivered); + SetStatusNode(EIdle); + } + + if (iCallback) + { + iCallback->DownloadComplete( this, iDownloadStatus); + } + + RDEBUG( "CDeploymentComponent::SuccessStatusUpdateL : end"); + } + +const TSmlProfileId& CDeploymentComponent::OwnerProfile() const + { + return iOwnerProfile; + } + +const TDesC8& CDeploymentComponent::MimeType() const + { + if (iMetaData->MimeType().Length() ) + { + return iMetaData->MimeType(); + } + return iData->MimeType(); + } + +TBool CDeploymentComponent::DownloadFailed() const // http or symbian error + { + return (iDownloadStatus >= 400 || iDownloadStatus < 0) ? ETrue : EFalse; + } + +TInt CDeploymentComponent::DownloadStatus() const + { + return iDownloadStatus; + } + +void CDeploymentComponent::DestroyL(CRepository &aRepository) + { + TDeploymentComponentState st(State() ); + if ( !(st == EDCSActive || st == EDCSInactive)) + { + RFs fs; + User::LeaveIfError(fs.Connect() ); + CleanupClosePushL(fs); + iMetaData->DestroyL(fs); + iData->DestroyL(fs); + CleanupStack::PopAndDestroy( &fs) ;// fs + } + + TInt err(aRepository.Delete(iInternalId) ); + RDEBUG_3( "CDeploymentComponent::DestroyL: Deleting %d in centrep resulted with status %d", iInternalId, err ); + } + +void CDeploymentComponent::SetOwner(const TInt &aInfo) + { + iOwner = aInfo; + } + +void CDeploymentComponent::SetIAPL(const TInt aIap) + { + RDEBUG8_2( "CDeploymentComponent::SetIAPL: %d ", aIap ); + iInstallOpts.iIAP = aIap; + } + +TInt CDeploymentComponent::GetIAP() const + { + return iInstallOpts.iIAP; + } +HBufC8* CDeploymentComponent::IntToDes8LC(const TInt aLuid) + { + HBufC8* buf = HBufC8::NewLC( 10); //10 = max length of 32bit integer + TPtr8 ptrBuf = buf->Des(); + ptrBuf.Num(aLuid); + return buf; + } + +// End of File