1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "swtypereginfo.h"

    20 

    21 using namespace Swi;

    22 

    23 CLocalizedSoftwareTypeName::CLocalizedSoftwareTypeName()

    24 	{

    25 	}

    26 

    27 CLocalizedSoftwareTypeName::CLocalizedSoftwareTypeName(TLanguage aLocale)

    28 	:	iLocale(aLocale)

    29 	{

    30 	}

    31 

    32 EXPORT_C CLocalizedSoftwareTypeName::~CLocalizedSoftwareTypeName()

    33 	{

    34 	delete iName;

    35 	}

    36 

    37 EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewL(const TDesC& aName, TLanguage aLocale)

    38 	{

    39 	CLocalizedSoftwareTypeName *self = CLocalizedSoftwareTypeName::NewLC(aName, aLocale);

    40 	CleanupStack::Pop(self);

    41 	return self;

    42 	}

    43 

    44 EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewLC(const TDesC& aName, TLanguage aLocale)

    45 	{

    46 	CLocalizedSoftwareTypeName *self = new(ELeave) CLocalizedSoftwareTypeName(aLocale);

    47 	CleanupStack::PushL(self);

    48 	self->iName = aName.AllocL();

    49 	return self;

    50 	}

    51 

    52 EXPORT_C CLocalizedSoftwareTypeName* CLocalizedSoftwareTypeName::NewL(RReadStream& aStream)

    53 	{

    54 	CLocalizedSoftwareTypeName* self = new(ELeave) CLocalizedSoftwareTypeName();

    55 	CleanupStack::PushL(self);

    56 	self->InternalizeL(aStream);

    57 	CleanupStack::Pop(self);

    58 	return self;

    59 	}

    60 

    61 EXPORT_C void CLocalizedSoftwareTypeName::ExternalizeL(RWriteStream& aStream) const

    62 	{

    63 	aStream.WriteInt32L(iLocale);

    64 	aStream << *iName;

    65 	}

    66 

    67 void CLocalizedSoftwareTypeName::InternalizeL(RReadStream& aStream)

    68 	{

    69 	TLanguage locale = static_cast<TLanguage>(aStream.ReadInt32L());

    70 	iLocale = locale;

    71 

    72 	delete iName;

    73 	iName = HBufC::NewL(aStream, KMaxTInt); // No restriction on length

    74 	}

    75 

    76 // ##########################################################################################

    77 

    78 EXPORT_C CSoftwareTypeRegInfo* CSoftwareTypeRegInfo::NewL(const TDesC& aUniqueSoftwareTypeName)

    79 	{

    80 	CSoftwareTypeRegInfo* self = new (ELeave) CSoftwareTypeRegInfo();

    81 	CleanupStack::PushL(self);

    82 	self->iUniqueSoftwareTypeName = HBufC::NewL(aUniqueSoftwareTypeName.Length());

    83 	self->iUniqueSoftwareTypeName->Des().Copy(aUniqueSoftwareTypeName);

    84 	CleanupStack::Pop(self);

    85 	return self;

    86 	}

    87 

    88 EXPORT_C CSoftwareTypeRegInfo* CSoftwareTypeRegInfo::NewL(RReadStream& aStream)

    89 	{

    90 	CSoftwareTypeRegInfo* self = new (ELeave) CSoftwareTypeRegInfo();

    91 	CleanupStack::PushL(self);

    92 	self->InternalizeL(aStream);

    93 	CleanupStack::Pop(self);

    94 	return self;

    95 	}

    96 

    97 CSoftwareTypeRegInfo::CSoftwareTypeRegInfo()

    98 	{

    99 	}

   100 

   101 EXPORT_C CSoftwareTypeRegInfo::~CSoftwareTypeRegInfo()

   102 	{

   103 	delete iUniqueSoftwareTypeName;

   104 	iMimeTypes.Close();

   105 	iLocalizedSoftwareTypeNames.Close();

   106 	}

   107 

   108 EXPORT_C void CSoftwareTypeRegInfo::ExternalizeL(RWriteStream& aStream) const

   109 	{

   110 	aStream << *iUniqueSoftwareTypeName;

   111 	aStream << iSifPluginUid.iUid;

   112 	

   113 	TUid installerUid = iInstallerSecureId;

   114 	aStream << installerUid.iUid;

   115 	

   116 	TUid executionLayerUid = iExecutionLayerSecureId;

   117 	aStream << executionLayerUid.iUid;

   118 	

   119 	// MIME types

   120 	const TInt numMimeTypes = iMimeTypes.Count();

   121 	aStream.WriteInt32L(numMimeTypes);

   122 	for (TInt i=0; i<numMimeTypes; ++i)

   123 		{

   124 		aStream << *iMimeTypes[i];

   125 		}

   126 	 

   127 	// Localized names

   128 	const TInt numLocalizedNames = iLocalizedSoftwareTypeNames.Count();

   129 	aStream.WriteInt32L(numLocalizedNames);

   130 	for (TInt i=0; i<numLocalizedNames; ++i)

   131 		{

   132 		aStream << *iLocalizedSoftwareTypeNames[i];

   133 		}

   134 	}

   135 

   136 EXPORT_C TInt CSoftwareTypeRegInfo::ExternalizedSize() const

   137 	{

   138 	TInt size = sizeof(TUid) + sizeof(TSecureId) + sizeof(TSecureId);

   139 	size += sizeof(TInt) + iUniqueSoftwareTypeName->Size();

   140 	

   141 	// MIME types

   142 	const TInt numMimeTypes = iMimeTypes.Count();

   143 	size += sizeof(TInt);

   144 	for (TInt i=0; i<numMimeTypes; ++i)

   145 		{

   146 		size += sizeof(TInt) + iMimeTypes[i]->Size();

   147 		}

   148 	 

   149 	// Localized names

   150 	const TInt numLocalizedNames = iLocalizedSoftwareTypeNames.Count();

   151 	size += sizeof(TInt);

   152 	for (TInt i=0; i<numLocalizedNames; ++i)

   153 		{

   154 		size += sizeof(TInt) + sizeof(TInt) + iLocalizedSoftwareTypeNames[i]->Name().Size();

   155 		}

   156 

   157 	return size;

   158 	}

   159 

   160 void CSoftwareTypeRegInfo::InternalizeL(RReadStream& aStream)

   161 	{

   162 	ASSERT(iUniqueSoftwareTypeName == NULL);

   163 	

   164 	iUniqueSoftwareTypeName = HBufC::NewL(aStream, EUniqueSwTypeNameMaxLength);

   165 	

   166 	iSifPluginUid = TUid::Uid(aStream.ReadInt32L());

   167 	iInstallerSecureId = TUid::Uid(aStream.ReadInt32L());

   168 	iExecutionLayerSecureId = TUid::Uid(aStream.ReadInt32L());

   169 	

   170 	// MIME types

   171 	const TInt numMimeTypes = aStream.ReadInt32L();

   172 	for (TInt i=0; i<numMimeTypes; ++i)

   173 		{

   174 		HBufC* mimeType = HBufC::NewLC(aStream, EUniqueSwTypeNameMaxLength);

   175 		iMimeTypes.AppendL(mimeType);

   176 		CleanupStack::Pop(mimeType);

   177 		}

   178 	

   179 	// Localized names

   180 	const TInt numLocalizedNames = aStream.ReadInt32L();

   181 	for (TInt i=0; i<numLocalizedNames; ++i)

   182 		{

   183 		CLocalizedSoftwareTypeName* name = CLocalizedSoftwareTypeName::NewL(aStream);

   184 		CleanupStack::PushL(name);

   185 		iLocalizedSoftwareTypeNames.AppendL(name);

   186 		CleanupStack::Pop(name);

   187 		}

   188 	}

   189 

   190 EXPORT_C void CSoftwareTypeRegInfo::SetMimeTypeL(const TDesC& aMimeType)

   191 	{

   192 	HBufC* mimeType = HBufC::NewLC(aMimeType.Length());

   193 	mimeType->Des().Copy(aMimeType);

   194 	iMimeTypes.AppendL(mimeType);

   195 	CleanupStack::Pop(mimeType);

   196 	}

   197 

   198 EXPORT_C void CSoftwareTypeRegInfo::SetLocalizedSoftwareTypeNameL(TLanguage aLanguage, const TDesC& aName)

   199 	{

   200 	CLocalizedSoftwareTypeName* name = CLocalizedSoftwareTypeName::NewLC(aName, aLanguage);

   201 	iLocalizedSoftwareTypeNames.AppendL(name);

   202 	CleanupStack::Pop(name);

   203 	}

   204 

   205 // ##########################################################################################

   206 

   207 EXPORT_C void SoftwareTypeRegInfoUtils::SerializeArrayL(const RPointerArray<CSoftwareTypeRegInfo>& aSwTypeRegInfoArray, RBuf8& aSerializedArray)

   208 	{

   209 	TInt bufLen = sizeof(TInt);

   210 	const TInt count = aSwTypeRegInfoArray.Count();

   211 	for (TInt i=0; i<count; ++i)

   212 		{

   213 		bufLen += aSwTypeRegInfoArray[i]->ExternalizedSize();

   214 		}

   215 

   216 	aSerializedArray.ReAllocL(aSerializedArray.Length()+bufLen);

   217 	RDesWriteStream ws(aSerializedArray);

   218 	CleanupClosePushL(ws);

   219 

   220 	ws.WriteInt32L(count);

   221 	for (TInt i=0; i<count; ++i)

   222 		{

   223 		const CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i];

   224 		ws << info;

   225 		}

   226 

   227 	ws.CommitL();

   228 	CleanupStack::PopAndDestroy(&ws);

   229 	}

   230 

   231 EXPORT_C void SoftwareTypeRegInfoUtils::UnserializeArrayL(RReadStream& aStream, RPointerArray<CSoftwareTypeRegInfo>& aSwTypeRegInfoArray)

   232 	{

   233 	const TInt numElems = aStream.ReadInt32L();

   234 	for (TInt i=0; i<numElems; ++i)

   235 		{

   236 		CSoftwareTypeRegInfo* info = CSoftwareTypeRegInfo::NewL(aStream);

   237 		CleanupStack::PushL(info);

   238 		aSwTypeRegInfoArray.AppendL(info);

   239 		CleanupStack::Pop(info);

   240 		}

   241 	}

   242 

   243 EXPORT_C void SoftwareTypeRegInfoUtils::SerializeUniqueSwTypeNamesL(const RPointerArray<CSoftwareTypeRegInfo>& aSwTypeRegInfoArray, RBuf& aSerializedNames)

   244 	{

   245 	const TInt numNames = aSwTypeRegInfoArray.Count();

   246 	

   247 	TInt bufLen = 0;

   248 	for (TInt i=0; i<numNames; ++i)

   249 		{

   250 		const CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i];

   251 		bufLen += info.UniqueSoftwareTypeName().Length() + sizeof(TChar);

   252 		}

   253 	

   254 	aSerializedNames.ReAllocL(aSerializedNames.Length()+bufLen);

   255 	

   256 	for (TInt i=0; i<numNames; ++i)

   257 		{

   258 		const CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i];

   259 		aSerializedNames.Append(info.UniqueSoftwareTypeName());

   260 		aSerializedNames.Append(static_cast<TChar>(KUniqueNameSeparator));

   261 		}

   262 	}

   263 

   264 EXPORT_C void SoftwareTypeRegInfoUtils::UnserializeUniqueSwTypeNamesL(const TDesC& aSerializedNames, RArray<TPtrC>& aUniqueSwTypeNames)

   265 	{

   266 	TPtrC buf(aSerializedNames);

   267 	for (;;)

   268 		{

   269 		const TInt sep = buf.Locate(static_cast<TChar>(KUniqueNameSeparator));

   270 		if (sep != KErrNotFound)

   271 			{

   272 			aUniqueSwTypeNames.AppendL(buf.Left(sep));

   273 			buf.Set(buf.Mid(sep+1));

   274 			}

   275 		else

   276 			{

   277 			if (buf.Length() > 0)

   278 				{

   279 				User::Leave(KErrGeneral);

   280 				}

   281 			break;

   282 			}

   283 		}

   284 	}

   285 

   286 EXPORT_C void SoftwareTypeRegInfoUtils::ExtractMimeTypesL(const RPointerArray<CSoftwareTypeRegInfo>& aSwTypeRegInfoArray, RPointerArray<HBufC8>& aMimeTypes)

   287 	{

   288 	for (TInt i=0; i<aSwTypeRegInfoArray.Count(); ++i)

   289 		{

   290 		const RPointerArray<HBufC>& mimeTypes = aSwTypeRegInfoArray[i]->MimeTypes();

   291 		for (TInt m=0; m<mimeTypes.Count(); ++m)

   292 			{

   293 			const TDesC& mimeType = *mimeTypes[m];

   294 			HBufC8* mimeType8 = HBufC8::NewLC(mimeType.Length());

   295 			mimeType8->Des().Copy(mimeType);

   296 

   297 			aMimeTypes.AppendL(mimeType8);

   298 

   299 			CleanupStack::Pop(mimeType8);

   300 			}

   301 		}

   302 	}