diff -r f5050f1da672 -r 04becd199f91 javatools/javaapppreconverter/src.s60/midletlist.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javatools/javaapppreconverter/src.s60/midletlist.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,513 @@ +/* +* Copyright (c) 2008 - 2009 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: Java platform 2.0 javaapppreconverter process +* +*/ + +#include "midletlist.h" + + + +CMidletInfo::CMidletInfo() : + iMidletUid(TUid::Null()), iMidletId(KMaxTUint32), iSuiteId(KMaxTUint32), + iMidletName(NULL), iGroupName(NULL), iDrive(EDriveE) +{ +} + +CMidletInfo::CMidletInfo(CMidletInfo* aMidletInfo) +{ + iMidletUid = aMidletInfo->GetMidletUid(); + iMidletId = aMidletInfo->GetMidletId(); + iSuiteId = aMidletInfo->GetSuiteId(); + iMidletName = aMidletInfo->GetMidletName().Alloc(); + iGroupName = aMidletInfo->GetGroupName().Alloc(); + iDrive = aMidletInfo->GetDrive(); + iIconFileName = aMidletInfo->GetIconFileName(); +} + + +CMidletInfo::~CMidletInfo() +{ + delete iMidletName; + delete iGroupName; +} + + +TUid CMidletInfo::GetMidletUid() const +{ + return iMidletUid; +} + +TUint32 CMidletInfo::GetMidletId() const +{ + return iMidletId; +} + +TUint32 CMidletInfo::GetSuiteId() const +{ + return iSuiteId; +} + +const TDesC& CMidletInfo::GetMidletName() +{ + if (NULL == iMidletName) + { + return KNullDesC; + } + else + { + return *iMidletName; + } +} + +const TDesC& CMidletInfo::GetGroupName() +{ + if (NULL == iGroupName) + { + return KNullDesC; + } + else + { + return *iGroupName; + } +} + +TDriveNumber CMidletInfo::GetDrive() +{ + return iDrive; +} + +const TFileName& CMidletInfo::GetIconFileName() +{ + return iIconFileName; +} + + + + +void CMidletInfo::SetMidletUid(const TUid aUid) +{ + iMidletUid = aUid; +} + +void CMidletInfo::SetMidletId(const TUint32 aId) +{ + iMidletId = aId; +} + +void CMidletInfo::SetSuiteId(const TUint32 aId) +{ + iSuiteId = aId; +} + +void CMidletInfo::SetMidletName(const TDesC& aName) +{ + iMidletName = aName.Alloc(); +} + +void CMidletInfo::SetGroupName(const TDesC& aName) +{ + iGroupName = aName.Alloc(); +} + +void CMidletInfo::SetDrive(const TDriveNumber aDrive) +{ + iDrive = aDrive; +} + +void CMidletInfo::SetIconFileName(HBufC16 *aIconFileName) +{ + iIconFileName = *aIconFileName; +} + +void CMidletInfo::SetIconFileName(const TFileName &aIconFileName) +{ + iIconFileName = aIconFileName; +} + +void CMidletInfo::ExternalizeL(RWriteStream& aStream) const +{ + aStream.WriteUint32L(iMidletUid.iUid); + aStream.WriteUint32L(iMidletId); + aStream.WriteUint32L(iSuiteId); + + TInt32 nLen = 0; + if (iMidletName) + { + nLen = iMidletName->Length(); + } + aStream.WriteInt32L(nLen); + if (nLen > 0) + { + aStream.WriteL(*iMidletName); + } + + nLen = 0; + if (iGroupName) + { + nLen = iGroupName->Length(); + } + aStream.WriteInt32L(nLen); + if (nLen > 0) + { + aStream.WriteL(*iGroupName); + } + + aStream.WriteUint32L(iDrive); + + nLen = iIconFileName.Length(); + aStream.WriteInt32L(nLen); + if (nLen > 0) + { + aStream.WriteL(iIconFileName); + } + +} + +void CMidletInfo::InternalizeL(RReadStream& aStream) +{ + iMidletUid.iUid = aStream.ReadUint32L(); + iMidletId = aStream.ReadUint32L(); + iSuiteId = aStream.ReadUint32L(); + + TInt32 nLen = 0; + nLen = aStream.ReadInt32L(); + if (nLen > 0) + { + if (!iMidletName) + { + iMidletName = HBufC16::NewL(nLen + 8); + } + + TPtr16 tmpDes = iMidletName->Des(); + aStream.ReadL(tmpDes, nLen); + } + else + { + if (!iMidletName) + { + // empty midlet name + iMidletName = HBufC16::NewL(8); + } + } + + nLen = aStream.ReadInt32L(); + if (nLen > 0) + { + if (!iGroupName) + { + iGroupName = HBufC16::NewL(nLen + 8); + } + TPtr16 tmpDes = iGroupName->Des(); + aStream.ReadL(tmpDes, nLen); + } + else + { + if (!iGroupName) + { + // empty group name + iGroupName = HBufC16::NewL(8); + } + } + + iDrive = (TDriveNumber)aStream.ReadUint32L(); + + nLen = aStream.ReadInt32L(); + if (nLen > 0) + { + aStream.ReadL(iIconFileName, nLen); + } +} + +void CMidletInfo::ToString8(TDes8& aDescription) +{ + aDescription.Append(_L8("Uid: ")); + aDescription.AppendNumFixedWidth(iMidletUid.iUid, EHex, 8); + aDescription.Append(_L8("\nMidlet id: ")); + aDescription.AppendNumFixedWidth(iMidletId, EDecimal, 8); + aDescription.Append(_L8("\nSuite id: ")); + aDescription.AppendNumFixedWidth(iSuiteId, EDecimal, 8); + aDescription.Append(_L8("\nName: ")); + // Midlet name len is not limited. Make sure that buffer does not overflow. + aDescription.Append((*iMidletName).Left(256)); + aDescription.Append(_L8("\nGroup: ")); + // Group name is max 32 characters + aDescription.Append(*iGroupName); + aDescription.Append(_L8("\nDrive: ")); + aDescription.AppendNumFixedWidth(iDrive, EDecimal, 2); +} + +/* ---------------------------------------------------------------------------- */ + + + + +CMidletList::CMidletList() : + iMidletArray(RPointerArray()), iGetNextIndex(0), + iMidletArrayDestroyed(EFalse) +{ + +} + +CMidletList::~CMidletList() +{ + // Free the memory used by the RPointerArray. + // Do not destroy objects itself. + if (!iMidletArrayDestroyed) + { + iMidletArray.Close(); + } +} + +void CMidletList::ResetAndDestroy() +{ + iMidletArray.ResetAndDestroy(); + iMidletArrayDestroyed = ETrue; +} + +TInt CMidletList::Append(const CMidletInfo* aMidletInfo) +{ + if (NULL != Find(aMidletInfo->GetMidletUid())) + { + // midlet is already in list, do nothing + return KErrNone; + } + + return iMidletArray.Append(aMidletInfo); +} + +void CMidletList::Remove(const CMidletInfo* aMidletInfo) +{ + TInt nInd = iMidletArray.Find(aMidletInfo); + if (nInd < 0) + { + // The object is not in list, do nothing + return; + } + else if (nInd < iGetNextIndex) + { + // Removing one of the objects already returned by + // getNext(), the indexes of the objects not yet returned by + // getNext() are decreased by one. Must decrease iGetNextIndex too. + iGetNextIndex--; + } + + iMidletArray.Remove(nInd); +} + +TInt CMidletList::Count() const +{ + return iMidletArray.Count(); +} + +CMidletInfo* CMidletList::GetFirst() +{ + iGetNextIndex = 1; + + if (iMidletArray.Count() > 0) + { + return iMidletArray[0]; + } + else + { + return NULL; + } +} + +CMidletInfo* CMidletList::GetNext() +{ + if (iMidletArray.Count() > iGetNextIndex) + { + iGetNextIndex++; + return iMidletArray[iGetNextIndex-1]; + } + else + { + return NULL; + } +} + +CMidletInfo *CMidletList::Find(const TUid aMidletUid) +{ + TInt nCount = iMidletArray.Count(); + + for (TInt nInd = 0; nInd < nCount; nInd++) + { + if (iMidletArray[nInd]->GetMidletUid() == aMidletUid) + { + return iMidletArray[nInd]; + } + } + + return NULL; +} + +/** + * Return the first midlet that has name specified by aName and + * for which the midlet id and suite id have not yet been set. + * If midlet id and suite id have been set for all midlets with + * name specified by aName, returns the first midlet with name + * specified by aName + */ +CMidletInfo *CMidletList::Find(const TPtrC &aName) +{ + CMidletInfo *firstFound = NULL; + TInt nCount = iMidletArray.Count(); + + for (TInt nInd = 0; nInd < nCount; nInd++) + { + if (iMidletArray[nInd]->GetMidletName() == aName) + { + // If midlet id and suite id have already been set, + // find next midlet with the same name if any. + // If no such midlet, return this one. + if (NULL == firstFound) + { + firstFound = iMidletArray[nInd]; + } + if ((iMidletArray[nInd]->GetSuiteId() == KMaxTUint32) && + (iMidletArray[nInd]->GetMidletId() == KMaxTUint32)) + { + return iMidletArray[nInd]; + } + } + } + + return firstFound; +} + +void CMidletList::SetIds( + const TUint32 aUid, + const TUint32 aMidletSuiteId, + const TUint32 aMidletId) +{ + TUid uid; + uid.iUid = aUid; + CMidletInfo *midlet = Find(uid); + + if (NULL != midlet) + { + midlet->SetSuiteId(aMidletSuiteId); + midlet->SetMidletId(aMidletId); + } +} + +void CMidletList::SetIds( + const TPtrC &aName, + const TUint32 aMidletSuiteId, + const TUint32 aMidletId) +{ + CMidletInfo *midlet = Find(aName); + + if (NULL != midlet) + { + midlet->SetSuiteId(aMidletSuiteId); + midlet->SetMidletId(aMidletId); + } +} + +void CMidletList::ExportListL(RFs& aFs, const TFileName &aDirectory) +{ + if (iMidletArrayDestroyed || (iMidletArray.Count() == 0)) + { + // Trying to export empty list is an error + User::Leave(KErrArgument); + } + + // Create directory if it does not exist + TInt err= aFs.MkDirAll(aDirectory); + if ((KErrNone != err) && (KErrAlreadyExists != err)) + { + User::Leave(err); + } + + // Copy all icon files to directory + CFileMan *fm = CFileMan::NewL(aFs); + CleanupStack::PushL(fm); + CMidletInfo *midlet = GetFirst(); + TFileName newIconFileName; + TParse nameParser; + TUint32 nMidlets = 0; + + while (NULL != midlet) + { + User::LeaveIfError(fm->Copy(midlet->GetIconFileName(), aDirectory)); + + // set new icon file name + newIconFileName = aDirectory; + User::LeaveIfError(nameParser.Set(midlet->GetIconFileName(), NULL, NULL)); + newIconFileName.Append(nameParser.NameAndExt()); + midlet->SetIconFileName(newIconFileName); + + nMidlets++; + midlet = GetNext(); + } + + // Store all midlet info to a file in the directory + TFileName dataFilename = aDirectory; + dataFilename.Append(KMidletExportDataFileName); + + // Construct write stream so that new data file is created. + // If the file already exists, leave + RFileWriteStream writeStream; + User::LeaveIfError(writeStream.Create(aFs, dataFilename, EFileWrite)); + CleanupClosePushL(writeStream); + + // Write the number of midlets + writeStream.WriteUint32L(nMidlets); + + // write the midlet info one by one + midlet = GetFirst(); + while (NULL != midlet) + { + midlet->ExternalizeL(writeStream); + midlet = GetNext(); + } + + CleanupStack::PopAndDestroy(); // writeStream + CleanupStack::PopAndDestroy(fm); +} + +void CMidletList::ImportListL(RFs& aFs, const TFileName &aDirectory) +{ + CMidletInfo *midlet = NULL; + + // Form the data file name + TFileName dataFilename = aDirectory; + dataFilename.Append(KMidletExportDataFileName); + + // Open existing data file. If the file does not exist, leave + RFileReadStream readStream; + User::LeaveIfError(readStream.Open(aFs, dataFilename, EFileRead)); + CleanupClosePushL(readStream); + + // Read the number of midlets + TUint32 nMidlets = readStream.ReadUint32L(); + + for (TInt nInd = 0; nInd < nMidlets; nInd++) + { + // Read info of one midlet + midlet = new(ELeave) CMidletInfo; + CleanupStack::PushL(midlet); + midlet->InternalizeL(readStream); + + // Add it to list + Append(midlet); + CleanupStack::Pop(midlet); + } + + // close readStream + CleanupStack::PopAndDestroy(); +} +