/*

* Copyright (c) 2005-2006 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:    Class for handling group of IAPs.*

*/

// INCLUDE FILES

#include "CIptvIapList.h"

#include "CIptvUtil.h"

#include "IptvDebug.h"

// ============================ MEMBER FUNCTIONS ===============================

//defined to move default constructor to private

CIptvIapList::CIptvIapList()

    {

    }

// -----------------------------------------------------------------------------

// CIptvIapList::NewL

// -----------------------------------------------------------------------------

//

EXPORT_C CIptvIapList* CIptvIapList::NewL()

    {

    CIptvIapList* self = new (ELeave) CIptvIapList;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::ConstructL

// -----------------------------------------------------------------------------

//

void CIptvIapList::ConstructL()

    {

    iIapList.Reset();

    }

// -----------------------------------------------------------------------------

// CIptvIapList::~CIptvIapList

// -----------------------------------------------------------------------------

//

EXPORT_C CIptvIapList::~CIptvIapList()

    {

    iIapList.Close();

    }

// -----------------------------------------------------------------------------

// CIptvIapList::AddIap

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvIapList::AddIap(TIptvIap& aIap)

    {

    if ( iIapList.Count() >= KIptvSmServicesDbMaxIaps )

        {

        return KErrOverflow;

        }

    return iIapList.Append( aIap );

    }

// -----------------------------------------------------------------------------

// CIptvIapList::AddIap

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvIapList::AddIap( TIptvIap& aIap, TBool aIgnoreMax )

    {

    if ( iIapList.Count() >= KIptvSmServicesDbMaxIaps && !aIgnoreMax )

        {

        return KErrOverflow;

        }

    return iIapList.Append( aIap );

    }

// -----------------------------------------------------------------------------

// CIptvIapList::DeleteIap

// -----------------------------------------------------------------------------

//    

EXPORT_C TInt CIptvIapList::DeleteIap( TUint8 aIndex )

    {

    if ( aIndex >= iIapList.Count() )

        {

        return KErrOverflow;

        }

    iIapList.Remove( aIndex );

    iIapList.Compress();

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::DeleteIap

// -----------------------------------------------------------------------------

//    

EXPORT_C TInt CIptvIapList::DeleteIap( TIptvIap& aIap )

    {

    TInt i;

    for ( i = 0; i < iIapList.Count(); i++ )

        {

        if ( aIap.iId == iIapList[i].iId )

            {

            iIapList.Remove( i );

            iIapList.Compress();

            return KErrNone;

            }

        }

    return KErrNotFound;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::ModifyIap

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvIapList::ModifyIap(TUint8 aIndex, TIptvIap& aIap)

    {

    if(aIndex > (iIapList.Count()-1))

        {

        return KErrOverflow;

        }

    iIapList.Remove(aIndex);

    iIapList.Insert(aIap, aIndex);

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::IapL

// -----------------------------------------------------------------------------

//

EXPORT_C TIptvIap& CIptvIapList::IapL( TUint8 aIndex )

    {

    if ( aIndex > (iIapList.Count()-1) )

        {

        User::Leave( KErrOverflow );

        }

    return iIapList[aIndex];

    }

// -----------------------------------------------------------------------------

// CIptvIapList::GetIap

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvIapList::GetIap( TUint8 aIndex, TIptvIap& aIap )

    {

    if ( aIndex > (iIapList.Count()-1) )

        {

        return KErrOverflow;

        }

    aIap.iId       = iIapList[aIndex].iId;

    aIap.iPriority = iIapList[aIndex].iPriority;

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::Count

// -----------------------------------------------------------------------------

//    

EXPORT_C TUint8 CIptvIapList::Count()

    {

    return static_cast<TUint8>(iIapList.Count());

    }

// -----------------------------------------------------------------------------

// CIptvIapList::ExternalizeL

// -----------------------------------------------------------------------------

//

EXPORT_C void CIptvIapList::ExternalizeL(RDesWriteStream& aStream) const

    {

    TUint8 count;

    count = static_cast<TUint8>(iIapList.Count());    

    aStream.WriteUint8L(count); 

    TUint8 i;

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

        {

        iIapList[i].ExternalizeL(aStream);

        }    

    }

// -----------------------------------------------------------------------------

// CIptvIapList::InternalizeL

// -----------------------------------------------------------------------------

//

EXPORT_C void CIptvIapList::InternalizeL(RDesReadStream& aStream)

    {

    TUint8 count;    

    count = aStream.ReadUint8L();

    //delete previous list data

    iIapList.Reset();

    //add uninitialized iaps

    TUint8 i;

    TIptvIap iap;

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

        {

        iIapList.Append(iap);

        }

    //init iaps with stream data

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

        {

        iIapList[i].InternalizeL(aStream);

        }

    }

// -----------------------------------------------------------------------------

// CIptvIapList::CountExternalizeSize

// -----------------------------------------------------------------------------

//

EXPORT_C TUint32 CIptvIapList::CountExternalizeSize()

    {

    TUint8 i;

    TUint32 externalizeSize = 1; //first item is count (1 byte)

    for(i = 0; i < iIapList.Count(); i++)

        {

        externalizeSize += iIapList[i].CountExternalizeSize();

        }

    return externalizeSize;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::SetL

// -----------------------------------------------------------------------------

//

EXPORT_C void CIptvIapList::SetL(CIptvIapList& aIapList)

    {

    HBufC8* iapDes = HBufC8::NewL(aIapList.CountExternalizeSize() +1);

    CleanupStack::PushL(iapDes);

    RDesWriteStream writeStream;

    TPtr8 iapPtr8(iapDes->Des());

    writeStream.Open(iapPtr8);

    aIapList.ExternalizeL(writeStream);

    writeStream.Close();

    RDesReadStream readStream;

    readStream.Open(iapDes->Des());

    InternalizeL(readStream);

    readStream.Close();

    CleanupStack::PopAndDestroy(iapDes);

    }

// -----------------------------------------------------------------------------

// CIptvIapList::SortByPriorityL

// Iaplist can have max of 10 items. This sorting is done as simply as possible

// to avoid errors. Don't copy paste this code to any larger lists.

// -----------------------------------------------------------------------------

//

EXPORT_C void CIptvIapList::SortByPriorityL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvIapList::SortByPriority()");

    CIptvIapList* iapListSorted;

    iapListSorted = CIptvIapList::NewL();

    CleanupStack::PushL( iapListSorted );

    TUint8 highestPriorityIndex;

    TUint8 i;

    TUint8 count;

    count = Count();

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

        {

        highestPriorityIndex = GetHighestPriorityIapIndexL();

        iapListSorted->AddIap( iIapList[highestPriorityIndex] );

        DeleteIap( highestPriorityIndex );

        }

    SetL(*iapListSorted);

    CleanupStack::PopAndDestroy(iapListSorted);

    IPTVLOGSTRING_LOW_LEVEL("CIptvIapList::SortByPriority() exit");

    }

// -----------------------------------------------------------------------------

// CIptvIapList::GetHighestPriorityIapIndexL

// -----------------------------------------------------------------------------

//

TUint8 CIptvIapList::GetHighestPriorityIapIndexL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvIapList::GetHighestPriorityIapIndexL()");

    if ( Count() < 1 )

        {

        IPTVLOGSTRING_HIGH_LEVEL("CIptvIapList:: Error: No IAPs set");

        User::Leave( KErrNotFound );

        }

    //small number = high priority

    TUint8 highestPriorityFound = 255;

    TUint8 highestPriorityIndex = 0;

    TUint16 i;

    for ( i = 0; i < Count(); i++ )

        {

        if ( highestPriorityFound > iIapList[i].iPriority )

            {

            highestPriorityFound = iIapList[i].iPriority;  //store current best priority

            highestPriorityIndex = i; //store current best priority location

            }

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvIapList::GetHighestPriorityIapIndex() exit");

    //return the index which had the highest priority (= smallest value)

    return highestPriorityIndex;

    }

// -----------------------------------------------------------------------------

// CIptvIapList::FindIap

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvIapList::FindIap( TUint32 aIapId, TUint8& aIndex )

    {

    TInt i;

    for ( i = 0; i < Count(); i++ )

        {

        if( iIapList[i].iId == aIapId )

            {

            aIndex = i;

            return KErrNone;

            } 

        }

    return KErrNotFound;

    }