diff -r e8c1ea2c6496 -r 8758140453c0 localisation/apparchitecture/apgrfx/APGAIR.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/localisation/apparchitecture/apgrfx/APGAIR.CPP Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,254 @@ +// Copyright (c) 2004-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 "Symbian Foundation License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "APGAIR.H" +#include "APGAPLST.H" +#include "APGICNFL.H" +#include "APFDEF.H" + +extern void CleanupServiceArray(TAny* aServiceArray); + +CApaAppInfoReader::CApaAppInfoReader(RFs& aFs, const TUid aAppUid) + : iFs(aFs), + iAppUid(aAppUid), + iTimeStamp(0), + iDefaultScreenNumber(0), +#ifndef SYMBIAN_APPARC_APPINFO_CACHE + iDefaultIconsUsed(EFalse), +#endif //SYMBIAN_APPARC_APPINFO_CACHE + iNonMbmIconFile(EFalse), + iLocalisableResourceFileTimeStamp(0), + iApplicationLanguage(ELangNone), + iIndexOfFirstOpenService(-1) + { + } + +CApaAppInfoReader::~CApaAppInfoReader() + { + delete iAppBinaryFullName; + delete iCaption; + delete iShortCaption; + delete iIcons; + if (iViewDataArray) + { + iViewDataArray->ResetAndDestroy(); + delete iViewDataArray; + } + delete iOwnedFileArray; + delete iIconFileName; + delete iLocalisableResourceFileName; + + if (iServiceArray) + { + CleanupServiceArray(iServiceArray); + iServiceArray = NULL; + } + delete iOpaqueData; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC* CApaAppInfoReader::AppBinaryFullName() + { + HBufC* fileName = iAppBinaryFullName; + iAppBinaryFullName = NULL; // ownership transferred to caller + return fileName; + } + +TUidType CApaAppInfoReader::AppBinaryUidType() const + { + return iAppBinaryUidType; + } + +TTime CApaAppInfoReader::TimeStamp() const + { + return iTimeStamp; + } + +TTime CApaAppInfoReader::IconFileTimeStamp() const + { + return iIconFileTimeStamp; + } + +void CApaAppInfoReader::Capability(TDes8& aCapabilityBuf) const + { + TApaAppCapabilityBuf buf(iCapability); + TApaAppCapability::CopyCapability(aCapabilityBuf, buf); + } + +TUint CApaAppInfoReader::DefaultScreenNumber() const + { + return iDefaultScreenNumber; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC* CApaAppInfoReader::Caption() + { + HBufC* caption = iCaption; + iCaption = NULL; // ownership transferred to caller + return caption; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC* CApaAppInfoReader::ShortCaption() + { + HBufC* shortCaption = iShortCaption; + iShortCaption = NULL; // ownership transferred to caller + return shortCaption; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +CApaAppIconArray* CApaAppInfoReader::Icons() + { + CApaAppIconArray* icons = iIcons; + iIcons = NULL; // ownership transferred to caller + return icons; + } + +#ifndef SYMBIAN_APPARC_APPINFO_CACHE +TBool CApaAppInfoReader::DefaultIconsUsed() const + { + return iDefaultIconsUsed; + } +#else +TInt CApaAppInfoReader::NumOfAppIcons() const + { + return iNumOfAppIcons; + } +#endif // SYMBIAN_APPARC_APPINFO_CACHE + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +CArrayPtrFlat* CApaAppInfoReader::Views() + { + CArrayPtrFlat* viewDataArray = iViewDataArray; + iViewDataArray = NULL; // ownership transferred to caller + return viewDataArray; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +CDesCArray* CApaAppInfoReader::OwnedFiles() + { + CDesCArray* ownedFileArray = iOwnedFileArray; + iOwnedFileArray = NULL; // ownership transferred to caller + return ownedFileArray; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC* CApaAppInfoReader::IconFileName() + { + HBufC* iconFileName = iIconFileName; + iIconFileName = NULL; // ownership transferred to caller + return iconFileName; + } + +TBool CApaAppInfoReader::NonMbmIconFile() const + { + return iNonMbmIconFile; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC* CApaAppInfoReader::LocalisableResourceFileName() + { + HBufC* localisableResourceFileName = iLocalisableResourceFileName; + iLocalisableResourceFileName = NULL; // ownership transferred to caller + return localisableResourceFileName; + } + +TTime CApaAppInfoReader::LocalisableResourceFileTimeStamp() const + { + return iLocalisableResourceFileTimeStamp; + } + +TLanguage CApaAppInfoReader::AppLanguage() const + { + return iApplicationLanguage; + } + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +CArrayFixFlat* CApaAppInfoReader::ServiceArray(TInt& aIndexOfFirstOpenService) + { + CArrayFixFlat* serviceArray = iServiceArray; + iServiceArray = NULL; + aIndexOfFirstOpenService = iIndexOfFirstOpenService; + return serviceArray; + } + + +// The behaviour of the following function is a little non-standard, as it +// transfers ownership of the pointer owned by a CApaAppInfoReader derived object +// to the caller. This means that this function is only designed to be called once. +// Doing things this way provides a small performance optimisation by enabling the caller +// to delete it's stored pointer, and replace it with one returned by this function, +// instead of having to copy the object (copying could be expensive for the methods +// of this class that need to return arrays). +HBufC8* CApaAppInfoReader::OpaqueData() + { + HBufC8* opaqueData = iOpaqueData; + iOpaqueData = NULL; + return opaqueData; + }