--- a/installationservices/swinstallationfw/source/sifcommon.cpp Tue Aug 31 15:21:33 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1264 +0,0 @@
-/*
-* Copyright (c) 2008-2010 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 <f32file.h>
-#include <usif/sif/sifcommon.h>
-#include <s32mem.h>
-#include <scs/cleanuputils.h>
-#include <scs/streamingarray.h>
-#include "sifcommon_internal.h"
-
-using namespace Usif;
-
-/**
- The COpaqueNamedParams and CComponentInfo containers implement the deferred internalization
- logic. This mechanism is necessary because these containers may be passed through IPC between
- the SIF client and server. Hence, they must be externalized and internalized on both sides.
- However, The SIF client doesn't implement an active object and therefore it cannot internalize
- parameters returned by the SIF server. This de-serialization is done by the deferred internalization
- logic when the user accesses them first time.
- Hence, all the get methods, for example Name(), GetIntByName(), StringByNameL(), call the
- InternalizeFromExternalBufferL() method which calls ConstInternalizeL() in order to unpack
- the data recived from the SIF server if there is any. ConstInternalizeL() is a const method despite
- the fact it modifies class'es members. This is done to keep the get methods const as expected by
- the users.
- */
-
-// ##########################################################################################
-
-namespace
- {
- TInt PackCapabilitySet(const TCapabilitySet& aCapSet)
- {
- TInt caps=0;
- for (TInt c=0; c<ECapability_Limit; ++c)
- {
- if (aCapSet.HasCapability(TCapability(c)))
- {
- caps += (1<<c);
- }
- }
- return caps;
- }
-
- void UnpackCapabilitySet(TInt aPackedCapSet, TCapabilitySet& aCapSet)
- {
- for (TInt c=0; c<ECapability_Limit; ++c)
- {
- const TInt cap = 1<<c;
- if (aPackedCapSet&cap)
- {
- aCapSet.AddCapability(TCapability(c));
- }
- }
- }
- }
-
-// ##########################################################################################
-
-EXPORT_C TSecurityContext::TSecurityContext(const RMessage2& aMessage): iMsg(aMessage)
- {
- }
-
-EXPORT_C TBool TSecurityContext::HasCapability(TCapability aCapability) const
- {
- return iMsg.HasCapability(aCapability);
- }
-
-EXPORT_C void TSecurityContext::HasCapabilityL(TCapability aCapability) const
- {
- iMsg.HasCapabilityL(aCapability);
- }
-
-EXPORT_C TSecureId TSecurityContext::SecureId() const
- {
- return iMsg.SecureId();
- }
-
-// ##########################################################################################
-
-CComponentInfo::CApplicationInfo::CApplicationInfo()
- {
- }
-
-EXPORT_C CComponentInfo::CApplicationInfo::~CApplicationInfo()
- {
- delete iName;
- delete iGroupName;
- delete iIconFileName;
- }
-
-EXPORT_C CComponentInfo::CApplicationInfo* CComponentInfo::CApplicationInfo::NewLC(const TUid& aAppUid, const TDesC& aName, const TDesC& aGroupName, const TDesC& aIconFileName)
- {
- _LIT(emptyString,"");
- // Leave if aName, aGroupName or aIconFileName exceeds KMaxDescriptorLength
- if ((&aName != NULL && aName.Length() > KMaxDescriptorLength) ||
- (&aGroupName != NULL && aGroupName.Length() > KMaxDescriptorLength) ||
- (&aIconFileName != NULL && aIconFileName.Length() > KMaxDescriptorLength))
- {
- User::Leave(KErrOverflow);
- }
-
- CComponentInfo::CApplicationInfo* self = new (ELeave) CComponentInfo::CApplicationInfo();
- CleanupStack::PushL(self);
-
- self->iAppUid = aAppUid;
- if(&aName == NULL)
- {
- self->iName = emptyString().AllocL();
- }
- else
- {
- self->iName = aName.AllocL();
- }
-
- if(&aGroupName == NULL)
- {
- self->iGroupName = emptyString().AllocL();
- }
- else
- {
- self->iGroupName = aGroupName.AllocL();
- }
-
- if(&aIconFileName == NULL)
- {
- self->iIconFileName = emptyString().AllocL();
- }
- else
- {
- self->iIconFileName = aIconFileName.AllocL();
- }
-
- return self;
- }
-
-EXPORT_C const TUid& CComponentInfo::CApplicationInfo::AppUid() const
- {
- return iAppUid;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::Name() const
- {
- return *iName;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::GroupName() const
- {
- return *iGroupName;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CApplicationInfo::IconFileName() const
- {
- return *iIconFileName;
- }
-
-CComponentInfo::CApplicationInfo* CComponentInfo::CApplicationInfo::NewL(RReadStream& aStream)
- {
- CApplicationInfo* self = new (ELeave) CApplicationInfo();
- CleanupStack::PushL(self);
-
- self->iAppUid = TUid::Uid(aStream.ReadInt32L());
- self->iName = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iGroupName = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iIconFileName = HBufC::NewL(aStream, KMaxDescriptorLength);
-
- CleanupStack::Pop(self);
- return self;
- }
-
-void CComponentInfo::CApplicationInfo::ExternalizeL(RWriteStream& aStream) const
- {
- aStream.WriteInt32L(iAppUid.iUid);
- aStream << *iName;
- aStream << *iGroupName;
- aStream << *iIconFileName;
- }
-
-// ##########################################################################################
-
-CComponentInfo::CNode::CNode() : iAuthenticity(ENotAuthenticated)
- {
- iUserGrantableCaps.SetEmpty();
- }
-
-EXPORT_C CComponentInfo::CNode::~CNode()
- {
- delete iSoftwareTypeName;
- delete iComponentName;
- delete iGlobalComponentId;
- delete iVersion;
- delete iVendor;
-
- iApplications.Close();
- iChildren.Close();
- }
-
-EXPORT_C CComponentInfo::CNode* CComponentInfo::CNode::NewLC(const TDesC& aSoftwareTypeName, const TDesC& aComponentName,
- const TDesC& aVersion, const TDesC& aVendor, TScomoState aScomoState,
- TInstallStatus aInstallStatus, TComponentId aComponentId,
- const TDesC& aGlobalComponentId, TAuthenticity aAuthenticity,
- const TCapabilitySet& aUserGrantableCaps, TInt aMaxInstalledSize,
- TBool aHasExe, TBool aIsDriveSelectionRequired,
- RPointerArray<CApplicationInfo>* aApplications, RPointerArray<CNode>* aChildren)
- {
- // We leave if aSoftwareTypeName, aComponentName, aVersion, aVendor or aGlobalComponentId exceeds KMaxDescriptorLength
- if (aSoftwareTypeName.Length() > KMaxDescriptorLength ||
- aComponentName.Length() > KMaxDescriptorLength ||
- aVersion.Length() > KMaxDescriptorLength ||
- aVendor.Length() > KMaxDescriptorLength ||
- aGlobalComponentId.Length() > KMaxDescriptorLength)
- {
- User::Leave(KErrOverflow);
- }
-
-
- // Since the max heap buffer length is 2K, which is more than (num of parameters * KMaxDescriptorLength), we just assert this condition
- __ASSERT_ALWAYS(aSoftwareTypeName.Length() + aComponentName.Length() + aVersion.Length() + aVendor.Length() +
- aGlobalComponentId.Length() <= KMaxHeapBufLength, User::Leave(KErrOverflow));
-
- // Create an instance of CNode
- CNode* self = new (ELeave) CNode();
- CleanupStack::PushL(self);
-
- // Copy Software Type Name, Component Name, Version, aVendor, aGlobalComponentId
- self->iSoftwareTypeName = aSoftwareTypeName.AllocL();
- self->iComponentName = aComponentName.AllocL();
- self->iVersion = aVersion.AllocL();
- self->iVendor = aVendor.AllocL();
- self->iGlobalComponentId = aGlobalComponentId.AllocL();
-
- // Others
- self->iScomoState = aScomoState;
- self->iInstallStatus = aInstallStatus;
- self->iComponentId = aComponentId;
- self->iAuthenticity = aAuthenticity;
- self->iUserGrantableCaps = aUserGrantableCaps;
- self->iMaxInstalledSize = aMaxInstalledSize;
- self->iHasExe = aHasExe;
- self->iIsDriveSelectionRequired = aIsDriveSelectionRequired;
-
- if(aApplications != NULL)
- {
- for (TInt i=aApplications->Count()-1; i>=0; --i)
- {
- self->iApplications.InsertL((*aApplications)[i], 0);
- aApplications->Remove(i);
- }
- }
-
- // Embedded Components
- if(aChildren != NULL)
- {
- for (TInt i=aChildren->Count()-1; i>=0; --i)
- {
- self->iChildren.InsertL((*aChildren)[i], 0);
- aChildren->Remove(i);
- }
- }
-
- return self;
- }
-
-EXPORT_C void CComponentInfo::CNode::AddChildL(CComponentInfo::CNode* aChild)
- {
- if (aChild == NULL)
- {
- User::Leave(KErrArgument);
- }
-
- iChildren.AppendL(aChild);
- }
-
-CComponentInfo::CNode* CComponentInfo::CNode::NewL(RReadStream& aStream)
- {
- // Create an instance of CNode
- CNode* self = new (ELeave) CNode();
- CleanupStack::PushL(self);
-
- self->iSoftwareTypeName = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iComponentName = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iVersion = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iVendor = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iGlobalComponentId = HBufC::NewL(aStream, KMaxDescriptorLength);
- self->iScomoState = static_cast<TScomoState>(aStream.ReadInt32L());
- self->iInstallStatus = static_cast<TInstallStatus>(aStream.ReadInt32L());
- self->iComponentId = aStream.ReadInt32L();
- self->iAuthenticity = static_cast<TAuthenticity>(aStream.ReadInt32L());
- UnpackCapabilitySet(aStream.ReadInt32L(), self->iUserGrantableCaps);
- self->iMaxInstalledSize = aStream.ReadInt32L();
- self->iHasExe = aStream.ReadInt32L();
- self->iIsDriveSelectionRequired = aStream.ReadInt32L();
-
- const TInt numApplications = aStream.ReadInt32L();
- for (TInt i=0; i<numApplications; ++i)
- {
- CApplicationInfo* app = CApplicationInfo::NewL(aStream);
- CleanupStack::PushL(app);
- self->iApplications.AppendL(app);
- CleanupStack::Pop(app);
- }
-
- const TInt numChildren = aStream.ReadInt32L();
- for (TInt i=0; i<numChildren; ++i)
- {
- CNode* node = CNode::NewL(aStream);
- CleanupStack::PushL(node);
- self->iChildren.AppendL(node);
- CleanupStack::Pop(node);
- }
-
- CleanupStack::Pop(self);
- return self;
- }
-
-void CComponentInfo::CNode::ExternalizeL(RWriteStream& aStream) const
- {
- ASSERT (iSoftwareTypeName!=NULL && iComponentName!=NULL && iVersion!=NULL && iVendor!=NULL && iGlobalComponentId!=NULL);
-
- aStream << *iSoftwareTypeName;
- aStream << *iComponentName;
- aStream << *iVersion;
- aStream << *iVendor;
- aStream << *iGlobalComponentId;
-
- aStream.WriteInt32L(iScomoState);
- aStream.WriteInt32L(iInstallStatus);
- aStream.WriteInt32L(iComponentId);
- aStream.WriteInt32L(static_cast<TInt>(iAuthenticity));
- aStream.WriteInt32L(PackCapabilitySet(iUserGrantableCaps));
- aStream.WriteInt32L(iMaxInstalledSize);
- aStream.WriteInt32L(iHasExe);
- aStream.WriteInt32L(iIsDriveSelectionRequired);
-
- const TInt numApplications = iApplications.Count();
- aStream.WriteInt32L(numApplications);
- for (TInt i=0; i<numApplications; ++i)
- {
- iApplications[i]->ExternalizeL(aStream);
- }
-
- const TInt numChildren = iChildren.Count();
- aStream.WriteInt32L(numChildren);
- for (TInt i=0; i<numChildren; ++i)
- {
- iChildren[i]->ExternalizeL(aStream);
- }
- }
-
-EXPORT_C const TDesC& CComponentInfo::CNode::SoftwareTypeName() const
- {
- return *iSoftwareTypeName;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CNode::ComponentName() const
- {
- return *iComponentName;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CNode::Version() const
- {
- return *iVersion;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CNode::Vendor() const
- {
- return *iVendor;
- }
-
-EXPORT_C TScomoState CComponentInfo::CNode::ScomoState() const
- {
- return iScomoState;
- }
-
-EXPORT_C TInstallStatus CComponentInfo::CNode::InstallStatus() const
- {
- return iInstallStatus;
- }
-
-EXPORT_C TComponentId CComponentInfo::CNode::ComponentId() const
- {
- return iComponentId;
- }
-
-EXPORT_C const TDesC& CComponentInfo::CNode::GlobalComponentId() const
- {
- return *iGlobalComponentId;
- }
-
-EXPORT_C TAuthenticity CComponentInfo::CNode::Authenticity() const
- {
- return iAuthenticity;
- }
-
-EXPORT_C const TCapabilitySet& CComponentInfo::CNode::UserGrantableCaps() const
- {
- return iUserGrantableCaps;
- }
-
-EXPORT_C TInt CComponentInfo::CNode::MaxInstalledSize() const
- {
- return iMaxInstalledSize;
- }
-
-EXPORT_C TBool CComponentInfo::CNode::HasExecutable() const
- {
- return iHasExe;
- }
-
-EXPORT_C TBool CComponentInfo::CNode::DriveSeletionRequired() const
- {
- return iIsDriveSelectionRequired;
- }
-
-EXPORT_C const RPointerArray<CComponentInfo::CApplicationInfo>& CComponentInfo::CNode::Applications() const
- {
- return iApplications;
- }
-
-EXPORT_C const RPointerArray<CComponentInfo::CNode>& CComponentInfo::CNode::Children() const
- {
- return iChildren;
- }
-
-// ##########################################################################################
-
-CComponentInfo::CComponentInfo() : iExternalBufferPtr(NULL, 0, 0)
- {
- }
-
-EXPORT_C CComponentInfo::~CComponentInfo()
- {
- delete iRootNode;
-
- CleanupExternalBuffer();
- }
-
-EXPORT_C CComponentInfo* CComponentInfo::NewL()
- {
- return new (ELeave) CComponentInfo;
- }
-
-EXPORT_C CComponentInfo* CComponentInfo::NewLC()
- {
- CComponentInfo* self = new (ELeave) CComponentInfo;
- CleanupStack::PushL(self);
- return self;
- }
-
-EXPORT_C const CComponentInfo::CNode& CComponentInfo::RootNodeL() const
- {
- InternalizeFromExternalBufferL();
-
- if (iRootNode == NULL)
- {
- User::Leave(KErrNotFound);
- }
-
- return *iRootNode;
- }
-
-EXPORT_C void CComponentInfo::SetRootNodeL(CNode* aRootNode)
- {
- InternalizeFromExternalBufferL();
-
- if (aRootNode == NULL)
- {
- User::Leave(KErrArgument);
- }
-
- delete iRootNode;
- iRootNode = aRootNode;
- }
-
-EXPORT_C void CComponentInfo::SetRootNodeAsChildL(CNode& aParentNode)
- {
- InternalizeFromExternalBufferL();
-
- if (iRootNode == NULL)
- {
- User::Leave(KErrNotFound);
- }
-
- aParentNode.AddChildL(iRootNode);
- iRootNode = NULL;
- }
-
-EXPORT_C void CComponentInfo::ExternalizeL(RWriteStream& aStream) const
- {
- InternalizeFromExternalBufferL();
-
- aStream.WriteInt8L(iRootNode != NULL);
-
- if (iRootNode != NULL)
- {
- iRootNode->ExternalizeL(aStream);
- }
- }
-
-void CComponentInfo::ConstInternalizeL(RReadStream& aStream) const
- {
- CNode*& rootNode = const_cast<CNode*&>(iRootNode);
- delete rootNode;
- rootNode = NULL;
-
- if (aStream.ReadInt8L() != 0)
- {
- rootNode = CNode::NewL(aStream);
- }
- }
-
-void CComponentInfo::CleanupExternalBuffer() const
- {
- delete iExternalBuffer;
- iExternalBuffer = NULL;
- iDeferredInternalization = EFalse;
- }
-
-void CComponentInfo::InternalizeFromExternalBufferL() const
- {
- if (iDeferredInternalization)
- {
- iDeferredInternalization = EFalse;
-
- RDesReadStream rs(*iExternalBuffer);
- CleanupClosePushL(rs);
- ConstInternalizeL(rs);
- CleanupStack::PopAndDestroy(&rs);
-
- CleanupExternalBuffer();
- }
- }
-
-EXPORT_C void CComponentInfo::PrepareForIpcL(TIpcArgs& aIpcArgs, TInt aIndex)
- {
- delete iExternalBuffer;
- iExternalBuffer = NULL;
-
- iExternalBuffer = HBufC8::NewL(KMaxComponentInfoStreamedSize);
- iExternalBufferPtr.Set(iExternalBuffer->Des());
-
- aIpcArgs.Set(aIndex, &iExternalBufferPtr);
-
- iDeferredInternalization = ETrue;
- }
-
-// ##########################################################################################
-
-COpaqueNamedParams::COpaqueNamedParams()
- : iExternalBuffer(NULL), iExternalBufferPtr(NULL, 0, 0), iDeferredInternalization(EFalse), iExternalizedSize(2*sizeof(TInt))
- {
- }
-
-EXPORT_C COpaqueNamedParams::~COpaqueNamedParams()
- {
- Cleanup();
- iParams.Close();
- CleanupExternalBuffer();
- }
-
-EXPORT_C COpaqueNamedParams* COpaqueNamedParams::NewL()
- {
- return new (ELeave) COpaqueNamedParams;
- }
-
-EXPORT_C COpaqueNamedParams* COpaqueNamedParams::NewLC()
- {
- COpaqueNamedParams* self = new (ELeave) COpaqueNamedParams;
- CleanupStack::PushL(self);
- return self;
- }
-
-void COpaqueNamedParams::VerifyExternalizedSizeForNewParamArrayL(TInt aNameSize, TInt aValueSize) const
- {
- const TInt load = 2*sizeof(TInt) + aNameSize + aValueSize;
- if (aNameSize > KMaxOpaqueParamsDescriptorSize || iExternalizedSize + load > KMaxOpaqueParamsExternalizedSize)
- {
- User::Leave(KErrOverflow);
- }
- iExternalizedSize += load;
- }
-
-void COpaqueNamedParams::VerifyExternalizedSizeForExistingParamArrayL(TInt aOldValueSize, TInt aNewValueSize) const
- {
- const TInt diff = aNewValueSize - aOldValueSize;
- if (iExternalizedSize + diff > KMaxOpaqueParamsExternalizedSize)
- {
- User::Leave(KErrOverflow);
- }
- iExternalizedSize += diff;
- }
-
-EXPORT_C void COpaqueNamedParams::AddStringL(const TDesC& aName, const TDesC& aValue)
- {
- CStringItem* stringItem = CStringItem::NewL(aName, aValue);
- CleanupStack::PushL(stringItem);
-
- AddOpaqueParamL(stringItem);
- CleanupStack::Pop(stringItem);
- }
-
-EXPORT_C void COpaqueNamedParams::AddStringArrayL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
- {
- CStringArrayItem* stringArray = CStringArrayItem::NewL(aName, aValueArray);
- CleanupStack::PushL(stringArray);
-
- AddOpaqueParamL(stringArray);
- CleanupStack::Pop(stringArray);
- }
-
-EXPORT_C void COpaqueNamedParams::AddIntL(const TDesC& aName, TInt aValue)
- {
- CIntegerItem* integer = CIntegerItem::NewL(aName, aValue);
- CleanupStack::PushL(integer);
-
- AddOpaqueParamL(integer);
- CleanupStack::Pop(integer);
- }
-
-EXPORT_C void COpaqueNamedParams::AddIntArrayL(const TDesC& aName, const RArray<TInt>& aValueArray)
- {
- CIntegerArrayItem* integerArray = CIntegerArrayItem::NewL(aName, aValueArray);
- CleanupStack::PushL(integerArray);
-
- AddOpaqueParamL(integerArray);
- CleanupStack::Pop(integerArray);
- }
-
-void COpaqueNamedParams::AddOpaqueParamL(MOpaqueParam* aItemBase)
- {
- const TInt count = iParams.Count();
-
- for (TInt i=0; i<count; ++i)
- {
- if (iParams[i]->Name().CompareF(aItemBase->Name()) == 0)
- {
- VerifyExternalizedSizeForExistingParamArrayL(iParams[i]->ValueSize(), aItemBase->ValueSize());
-
- delete iParams[i];
- iParams[i] = aItemBase;
- return;
- }
- }
-
- VerifyExternalizedSizeForNewParamArrayL(aItemBase->Name().Size(), aItemBase->ValueSize());
- iParams.AppendL(aItemBase);
- }
-
-EXPORT_C void COpaqueNamedParams::GetNamesL(RPointerArray<HBufC>& aNames) const
- {
- InternalizeFromExternalBufferL();
-
- const TInt len = iParams.Count();
- for (TInt i=0; i<len; ++i)
- {
- HBufC* name = iParams[i]->Name().AllocLC();
- aNames.AppendL(name);
- CleanupStack::Pop(name);
- }
- }
-
-EXPORT_C void COpaqueNamedParams::ExternalizeL(RWriteStream& aStream) const
- {
- InternalizeFromExternalBufferL();
-
- TInt count = iParams.Count();
- aStream.WriteInt32L(count);
- for (TInt i=0; i<count; ++i)
- {
- aStream.WriteInt32L(iParams[i]->Type());
- iParams[i]->ExternalizeL(aStream);
- }
-
- aStream.WriteInt32L(iExternalizedSize);
- }
-
-EXPORT_C void COpaqueNamedParams::InternalizeL(RReadStream& aStream)
- {
- ConstInternalizeL(aStream);
- }
-
-void COpaqueNamedParams::ConstInternalizeL(RReadStream& aStream) const
- {
- ConstCleanup();
- RPointerArray<MOpaqueParam>& refParams = const_cast<RPointerArray<MOpaqueParam>& >(iParams);
-
- TInt count = aStream.ReadInt32L();
- for (TInt i=0; i<count; ++i)
- {
- MOpaqueParam::TType type = static_cast<MOpaqueParam::TType>(aStream.ReadInt32L());
- MOpaqueParam* param(0);
- switch(type)
- {
- case MOpaqueParam::EString:
- param = CStringItem::NewL(aStream);
- break;
-
- case MOpaqueParam::EStringArray:
- param = CStringArrayItem::NewL(aStream);
- break;
-
- case MOpaqueParam::EInteger:
- param = CIntegerItem::NewL(aStream);
- break;
-
- case MOpaqueParam::EIntegerArray:
- param = CIntegerArrayItem::NewL(aStream);
- break;
-
- default:
- User::Leave(KErrCorrupt);
- }
- CleanupStack::PushL(param);
- refParams.AppendL(param);
- CleanupStack::Pop(param);
- }
-
- iExternalizedSize = aStream.ReadInt32L();
- }
-
-EXPORT_C void COpaqueNamedParams::PrepareArgumentsForIpcL(TIpcArgs& aIpcArgs, TInt aIndex) const
- {
- delete iExternalBuffer;
- iExternalBuffer = NULL;
- iExternalBuffer = HBufC8::NewL(iExternalizedSize);
- iExternalBufferPtr.Set(iExternalBuffer->Des());
-
- RDesWriteStream ws(iExternalBufferPtr);
- CleanupClosePushL(ws);
- ExternalizeL(ws);
- ws.CommitL();
- CleanupStack::PopAndDestroy(&ws);
-
- aIpcArgs.Set(aIndex, &iExternalBufferPtr);
- }
-
-EXPORT_C void COpaqueNamedParams::PrepareResultsForIpcL(TIpcArgs& aIpcArgs, TInt aIndex)
- {
- delete iExternalBuffer;
- iExternalBuffer = NULL;
- iExternalBuffer = HBufC8::NewL(KMaxOpaqueParamsExternalizedSize);
- iExternalBufferPtr.Set(iExternalBuffer->Des());
-
- RDesWriteStream ws(iExternalBufferPtr);
- CleanupClosePushL(ws);
- ws.WriteInt32L(0); // Write the initial count of results, so that the object will be valid even if no results are added
- CleanupStack::PopAndDestroy(&ws);
-
- aIpcArgs.Set(aIndex, &iExternalBufferPtr);
-
- iDeferredInternalization = ETrue;
- }
-
-void COpaqueNamedParams::InternalizeFromExternalBufferL() const
- {
- if (iDeferredInternalization)
- {
- iDeferredInternalization = EFalse;
-
- RDesReadStream rs(*iExternalBuffer);
- CleanupClosePushL(rs);
- ConstInternalizeL(rs);
- CleanupStack::PopAndDestroy(&rs);
-
- CleanupExternalBuffer();
- }
- }
-
-EXPORT_C const TDesC& COpaqueNamedParams::StringByNameL(const TDesC& aName) const
- {
- InternalizeFromExternalBufferL();
-
- const TInt count = iParams.Count();
- for (TInt i=0; i<count; ++i)
- {
- if (iParams[i]->Type() == MOpaqueParam::EString && iParams[i]->Name().CompareF(aName) == 0)
- {
- CStringItem* string = static_cast<CStringItem*>(iParams[i]);
- return string->StringValue();
- }
- }
-
- return KNullDesC;
- }
-
-EXPORT_C const RPointerArray<HBufC>& COpaqueNamedParams::StringArrayByNameL(const TDesC& aName) const
- {
- InternalizeFromExternalBufferL();
-
- const TInt count = iParams.Count();
- TInt i;
- for (i=0; i<count; ++i)
- {
- if (iParams[i]->Type() == MOpaqueParam::EStringArray && iParams[i]->Name().CompareF(aName) == 0)
- {
- break;
- }
- }
-
- if(i == count)
- {
- User::Leave(KErrNotFound);
- }
- CStringArrayItem* stringArray = static_cast<CStringArrayItem*>(iParams[i]);
- return stringArray->StringArrayValue();
- }
-
-EXPORT_C TBool COpaqueNamedParams::GetIntByNameL(const TDesC& aName, TInt& aValue) const
- {
- InternalizeFromExternalBufferL();
-
- const TInt count = iParams.Count();
- for (TInt i=0; i<count; ++i)
- {
- if (iParams[i]->Type() == MOpaqueParam::EInteger && iParams[i]->Name().CompareF(aName) == 0)
- {
- CIntegerItem* integer = static_cast<CIntegerItem*>(iParams[i]);
- aValue = integer->IntegerValue();
- return ETrue;
- }
- }
-
- return EFalse;
- }
-
-EXPORT_C TInt COpaqueNamedParams::IntByNameL(const TDesC& aName) const
- {
- InternalizeFromExternalBufferL();
-
- TInt val;
- if (!GetIntByNameL(aName, val))
- {
- User::Leave(KErrNotFound);
- }
- return val;
- }
-
-EXPORT_C const RArray<TInt>& COpaqueNamedParams::IntArrayByNameL(const TDesC& aName) const
- {
- InternalizeFromExternalBufferL();
-
- const TInt count = iParams.Count();
- TInt i;
- for (i=0; i<count; ++i)
- {
- if (iParams[i]->Type() == MOpaqueParam::EIntegerArray && iParams[i]->Name().CompareF(aName) == 0)
- {
- break;
- }
- }
-
- if(i == count)
- {
- User::Leave(KErrNotFound);
- }
- CIntegerArrayItem* integerArray = static_cast<CIntegerArrayItem*>(iParams[i]);
- return integerArray->IntegerArrayValue();
- }
-
-EXPORT_C TInt COpaqueNamedParams::CountL() const
- {
- InternalizeFromExternalBufferL();
- return iParams.Count();
- }
-
-EXPORT_C void COpaqueNamedParams::Cleanup()
- {
- ConstCleanup();
- }
-
-void COpaqueNamedParams::ConstCleanup() const
- {
- // Cleanup internal params
- iExternalizedSize = 2*sizeof(TInt);
-
- RPointerArray<MOpaqueParam>& refParams = const_cast<RPointerArray<MOpaqueParam>&>(iParams);
- refParams.ResetAndDestroy();
- }
-
- void COpaqueNamedParams::CleanupExternalBuffer() const
- {
- delete iExternalBuffer;
- iExternalBuffer = NULL;
- iDeferredInternalization = EFalse;
- }
-
-
-/*
- * SifCommon internal classes
- */
-
-
-CItemBase::CItemBase(TType aType):
- iType(aType)
- {
-
- }
-
-CItemBase::TType CItemBase::Type() const
- {
- return iType;
- }
-
-void CItemBase::SetNameL(const TDesC& aName)
- {
- delete iName;
- iName = aName.AllocL();
- }
-
-
-CItemBase::~CItemBase()
- {
- delete iName;
- }
-
-const HBufC& CItemBase::Name() const
- {
- return *iName;
- }
-
-void CItemBase::SetValueSize(TInt aSize)
- {
- iSize = aSize;
- }
-
-TInt CItemBase::ValueSize() const
- {
- return iSize;
- }
-
-void CItemBase::VerifyExternalizedSizeForParamL(TUint aValueSize) const
- {
- if(aValueSize > KMaxOpaqueParamsDescriptorSize)
- {
- User::Leave(KErrOverflow);
- }
- }
-
-void CItemBase::ExternalizeL(RWriteStream& aStream) const
- {
- aStream << Name();
- aStream.WriteInt32L(iSize);
- }
-
-void CItemBase::InternalizeL (RReadStream& aStream)
- {
- delete iName;
- iName = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);
- iSize = aStream.ReadInt32L();
- }
-
-/*
- * CStringItem
- */
-CStringItem::CStringItem():
- CItemBase(EString)
- {
-
- }
-
-CStringItem* CStringItem::NewL(const TDesC& aName, const TDesC& aValue)
- {
- CStringItem* self = new(ELeave)CStringItem();
- CleanupStack::PushL(self);
- self->ConstructL(aName, aValue);
- CleanupStack::Pop(self);
- return self;
- }
-
-CStringItem* CStringItem::NewL(RReadStream& aStream)
- {
- CStringItem *self = new(ELeave)CStringItem();
- CleanupStack::PushL(self);
- self->InternalizeL(aStream);
- CleanupStack::Pop(self);
- return self;
- }
-
-void CStringItem::ConstructL(const TDesC& aName, const TDesC& aValue)
- {
- VerifyExternalizedSizeForParamL(aValue.Size());
- SetNameL(aName);
- iString = aValue.AllocL();
- SetValueSize(iString->Size());
- }
-
-CStringItem::~CStringItem()
- {
- delete iString;
- }
-
-void CStringItem::ExternalizeL(RWriteStream& aStream) const
- {
- CItemBase::ExternalizeL(aStream);
- aStream << *iString;
- }
-
-void CStringItem::InternalizeL(RReadStream& aStream)
- {
- CItemBase::InternalizeL(aStream);
- DeleteObjectZ(iString);
- iString = HBufC::NewL(aStream, KMaxOpaqueParamsDescriptorSize);
- }
-
-const TDesC& CStringItem::StringValue() const
- {
- return *iString;
- }
-
-const HBufC& CStringItem::Name() const
- {
- return CItemBase::Name();
- }
-
-MOpaqueParam::TType CStringItem::Type() const
- {
- return CItemBase::Type();
- }
-
-TInt CStringItem::ValueSize() const
- {
- return CItemBase::ValueSize();
- }
-/*
- * CStringArrayItem
- */
-
-CStringArrayItem::CStringArrayItem():
- CItemBase(EStringArray)
- {
-
- }
-
-CStringArrayItem* CStringArrayItem::NewL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
- {
- CStringArrayItem* self = new(ELeave)CStringArrayItem();
- CleanupStack::PushL(self);
- self->ConstructL(aName, aValueArray);
- CleanupStack::Pop(self);
- return self;
- }
-
-CStringArrayItem* CStringArrayItem::NewL(RReadStream& aStream)
- {
- CStringArrayItem *self = new(ELeave)CStringArrayItem();
- CleanupStack::PushL(self);
- self->InternalizeL(aStream);
- CleanupStack::Pop(self);
- return self;
- }
-
-void CStringArrayItem::ConstructL(const TDesC& aName, const RPointerArray<HBufC>& aValueArray)
- {
- SetNameL(aName);
- for(TInt i=0; i< aValueArray.Count(); ++i)
- {
- VerifyExternalizedSizeForParamL(aValueArray[i]->Size());
- HBufC* value = aValueArray[i]->AllocLC();
- iStringArray.AppendL(value);
- SetValueSize(ValueSize()+ value->Size());
- CleanupStack::Pop();
- }
- }
-
-void CStringArrayItem::ExternalizeL(RWriteStream& aStream) const
- {
- CItemBase::ExternalizeL(aStream);
- ExternalizePointersArrayL(iStringArray, aStream);
- }
-
-void CStringArrayItem::InternalizeL(RReadStream& aStream)
- {
- CItemBase::InternalizeL(aStream);
- iStringArray.ResetAndDestroy();
- InternalizePointersArrayL(iStringArray, aStream);
- }
-
-const RPointerArray<HBufC>& CStringArrayItem:: StringArrayValue() const
- {
- return iStringArray;
- }
-
-const HBufC& CStringArrayItem::Name() const
- {
- return CItemBase::Name();
- }
-
-MOpaqueParam::TType CStringArrayItem::Type() const
- {
- return CItemBase::Type();
- }
-
-TInt CStringArrayItem::ValueSize() const
- {
- return CItemBase::ValueSize();
- }
-
-CStringArrayItem::~CStringArrayItem()
- {
- iStringArray.ResetAndDestroy();
- }
-
-/*
- * CIntegerItem
- */
-
-CIntegerItem::CIntegerItem(TInt aValue):
- CItemBase(EInteger),
- iInteger(aValue)
- {
-
- }
-
-CIntegerItem* CIntegerItem::NewL(const TDesC& aName, TInt aValue)
- {
- CIntegerItem* self = new(ELeave)CIntegerItem(aValue);
- CleanupStack::PushL(self);
- self->ConstructL(aName);
- CleanupStack::Pop(self);
- return self;
- }
-
-CIntegerItem* CIntegerItem::NewL(RReadStream& aStream)
- {
- CIntegerItem *self = new(ELeave)CIntegerItem(0);
- CleanupStack::PushL(self);
- self->InternalizeL(aStream);
- CleanupStack::Pop(self);
- return self;
- }
-
-void CIntegerItem::ConstructL(const TDesC& aName)
- {
- SetNameL(aName);
- SetValueSize(sizeof(TInt));
- }
-
-void CIntegerItem::ExternalizeL(RWriteStream& aStream) const
- {
- CItemBase::ExternalizeL(aStream);
- aStream.WriteInt32L(iInteger);
- }
-
-void CIntegerItem::InternalizeL(RReadStream& aStream)
- {
- CItemBase::InternalizeL(aStream);
- iInteger = aStream.ReadInt32L();
- }
-
-TInt CIntegerItem::IntegerValue() const
- {
- return iInteger;
- }
-
-const HBufC& CIntegerItem::Name() const
- {
- return CItemBase::Name();
- }
-
-MOpaqueParam::TType CIntegerItem::Type() const
- {
- return CItemBase::Type();
- }
-
-TInt CIntegerItem::ValueSize() const
- {
- return CItemBase::ValueSize();
- }
-
-CIntegerItem::~CIntegerItem()
- {
- }
-
-/*
- * CIntegerArrayItem
- */
-
-CIntegerArrayItem::CIntegerArrayItem():
- CItemBase(EIntegerArray)
- {
-
- }
-
-CIntegerArrayItem* CIntegerArrayItem::NewL(const TDesC& aName, const RArray<TInt>& aValueArray)
- {
- CIntegerArrayItem* self = new(ELeave)CIntegerArrayItem();
- CleanupStack::PushL(self);
- self->ConstructL(aName, aValueArray);
- CleanupStack::Pop(self);
- return self;
- }
-
-CIntegerArrayItem* CIntegerArrayItem::NewL(RReadStream& aStream)
- {
- CIntegerArrayItem *self = new(ELeave)CIntegerArrayItem();
- CleanupStack::PushL(self);
- self->InternalizeL(aStream);
- CleanupStack::Pop(self);
- return self;
- }
-
-
-void CIntegerArrayItem::ConstructL(const TDesC& aName, const RArray<TInt>& aValueArray)
- {
- SetNameL(aName);
-
- for(TInt i=0; i<aValueArray.Count(); ++i)
- {
- iIntegerArray.AppendL(aValueArray[i]);
- SetValueSize(ValueSize()+sizeof(TInt));
- }
- }
-
-void CIntegerArrayItem::ExternalizeL(RWriteStream& aStream) const
- {
- CItemBase::ExternalizeL(aStream);
- ExternalizeFixedLengthArrayL(iIntegerArray, aStream);
- }
-
-void CIntegerArrayItem::InternalizeL(RReadStream& aStream)
- {
- CItemBase::InternalizeL(aStream);
- iIntegerArray.Reset();
- InternalizeFixedLengthArrayL(iIntegerArray, aStream);
- }
-
-const RArray<TInt>& CIntegerArrayItem::IntegerArrayValue() const
- {
- return iIntegerArray;
- }
-
-const HBufC& CIntegerArrayItem::Name() const
- {
- return CItemBase::Name();
- }
-
-MOpaqueParam::TType CIntegerArrayItem::Type() const
- {
- return CItemBase::Type();
- }
-
-TInt CIntegerArrayItem::ValueSize() const
- {
- return CItemBase::ValueSize();
- }
-
-CIntegerArrayItem::~CIntegerArrayItem()
- {
- iIntegerArray.Close();
- }