/*

* 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<CMidletInfo>()), 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();

}