/*

* Copyright (c) 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: Implementation of CUpnpCdsLiteObjectArray

*

*/

// INCLUDE FILES, SYSTEM

#include <f32file.h>        // TParse

#include <e32def.h>         // const_cast

#include <escapeutils.h>    // ConvertFromUnicodeToUtf8L

#include <upnpobject.h>

#include <upnpcontainer.h>

#include <upnpitem.h>

#include <upnpelement.h>

#include "upnpconstantdefs.h"

// INCLUDE FILES, USER

#include "upnpcdsliteobject.h"

#include "upnpcdsliteobjectarray.h"

#include "upnpsharingalgorithmconstants.h"

#include "upnplog.h"

// CONSTANTS

_LIT8( KSpace, " ");

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

// CUpnpCdsLiteObjectArray::NewL

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

//

EXPORT_C CUpnpCdsLiteObjectArray* CUpnpCdsLiteObjectArray::NewL()

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::NewL" );

    CUpnpCdsLiteObjectArray* self = new ( ELeave ) CUpnpCdsLiteObjectArray();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpCdsLiteObjectArray::~CUpnpCdsLiteObjectArray

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

//

EXPORT_C CUpnpCdsLiteObjectArray::~CUpnpCdsLiteObjectArray()

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

~CUpnpCdsLiteObjectArray" );

    // Empty and close the array

    iArray.ResetAndDestroy();

    }

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

// CUpnpCdsLiteObjectArray::AppendL

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

//

EXPORT_C void CUpnpCdsLiteObjectArray::AppendL( CUpnpCdsLiteObject *aObject )

    {

    // Validate the parameter

    if( !aObject ||

        aObject->Name() == KNullDesC8 ||

        aObject->ObjectId() == KNullDesC8 ||

        aObject->ParentId() == KNullDesC8 ||

        aObject->ObjectClass() == KNullDesC8 ||

        ( aObject->Type() != CUpnpCdsLiteObject::EContainer &&

          aObject->Type() != CUpnpCdsLiteObject::EItem &&

          aObject->Type() != CUpnpCdsLiteObject::EItemReference ) ||

        ( aObject->Type() == CUpnpCdsLiteObject::EItemReference &&

          aObject->OriginalItemIdL() == KNullDesC8 ) )

        {

        User::Leave( KErrArgument );

        }

    // Append the item into the array. Leave if there is a problem.

    TInt appendError = iArray.Append( aObject );

    if( appendError != KErrNone )

        {

        User::Leave( appendError );

        }

    }

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

// CUpnpCdsLiteObjectArray::FindByName

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::FindByName( TDesC8& aName )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::FindByName" );

    TInt returnvalue = KErrNotFound;

    // Continue only if the given parameter is valid

    if( aName != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, exit the loop

            if( aName.Match( iArray[index]->Name() ) >= 0 )

                {

                returnvalue = index;

                index = iArray.Count() + 1;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::FindByNameAndParentId

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::FindByNameAndParentId(

                                                   const TDesC8& aName,

                                                   const TDesC8& aParentId )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

FindByNameAndParentId" );

    TInt returnvalue = KErrNotFound;

    // Continue only if the given parameter is valid

    if( aName != KNullDesC8 && aParentId != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, exit the loop

            if( aName.Match( iArray[index]->Name() ) >= 0 &&

                aParentId.Match( iArray[index]->ParentId() ) >= 0 )

                {

                returnvalue = index;

                index = iArray.Count() + 1;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::FindByMediaClassAndParentId

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::FindByMediaClassAndParentId(

                                                  const TDesC8& aMediaClass,

                                                  const TDesC8& aParentId )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

FindByMediaClassAndParentId" );

    TInt returnvalue = KErrNotFound;

    // Continue only if the given parameter is valid

    if( aMediaClass != KNullDesC8 &&

        aParentId != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, exit the loop

            if( aMediaClass.Match( iArray[index]->ObjectClass() ) >= 0 &&

                aParentId.Match( iArray[index]->ParentId() ) >= 0 )

                {

                returnvalue = index;

                index = iArray.Count() + 1;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::FindByObjectId

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::FindByObjectId(

                                                 const TDesC8& aObjectId )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

FindByObjectId" );

    TInt returnvalue = KErrNotFound;

    // Continue only if the given parameter is valid

    if( aObjectId != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, exit the loop

            if( aObjectId.Match( iArray[index]->ObjectId() ) >= 0 )

                {

                returnvalue = index;

                index = iArray.Count() + 1;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::FindRefItemIdByOriginalIdL

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::FindRefItemIdByOriginalIdL(

                                                 const TDesC8& aOriginalId )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

FindRefItemIdByOriginalIdL" );

    TInt returnvalue = KErrNotFound;

    // Continue only if the given parameter is valid

    if( aOriginalId != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, exit the loop

            if( iArray[index]->Type() ==

                    CUpnpCdsLiteObject::EItemReference &&

                aOriginalId.Match( iArray[index]->OriginalItemIdL() ) >= 0 )

                {

                returnvalue = index;

                index = iArray.Count() + 1;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::ChildCount

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::ChildCount( const TDesC8& aObjectId )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::ChildCount" );

    TInt returnvalue ( 0 );

    // Continue only if the given parameter is valid

    if( aObjectId != KNullDesC8 )

        {

        // Go through the array

        for( TInt index=0; index<iArray.Count(); index++ )

            {

            // if a match is found, increase child count

            if( aObjectId.Match( iArray[index]->ParentId() ) >= 0 )

                {

                returnvalue++;

                }

            }

        }

    return returnvalue;

    }

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

// CUpnpCdsLiteObjectArray::Count

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

//

EXPORT_C TInt CUpnpCdsLiteObjectArray::Count( )

    {

    return iArray.Count();

    }

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

// CUpnpCdsLiteObjectArray::ObjectAtL

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

//

EXPORT_C CUpnpCdsLiteObject& CUpnpCdsLiteObjectArray::ObjectAtL(

                                                           TUint aIndex )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::ObjectAtL" );

    // Validate the parameter

    if( aIndex > iArray.Count() )

        {

        User::Leave( KErrArgument );

        }

    // Return a reference to the object

    CUpnpCdsLiteObject* object = iArray[aIndex];

    return *object;

    }

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

// CUpnpCdsLiteObjectArray::RemoveObjectAtL

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

//

EXPORT_C void CUpnpCdsLiteObjectArray::RemoveObjectAtL( TUint aIndex )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

RemoveObjectAtL" );

    // Validate the parameter

    if( aIndex > iArray.Count() )

        {

        User::Leave( KErrArgument );

        }

    // Get the pointer from the array

    CUpnpCdsLiteObject* object = iArray[aIndex];

    // Remove the object and compress the array

    iArray.Remove( aIndex );

    iArray.Compress();

    // Delete the object

    delete object;

    }

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

// CUpnpCdsLiteObjectArray::AppendL

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

//

EXPORT_C void CUpnpCdsLiteObjectArray::AppendL( const CUpnpObject *aObject )

    {

    // First, create a new CreateUpnpCdsLiteObject

    CUpnpCdsLiteObject* object = CreateUpnpCdsLiteObjectL( aObject );

    CleanupStack::PushL( object );

    // Append the item to the array

    AppendL( object );

    CleanupStack::Pop( object ); // ownership transfered

    }

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

// CUpnpCdsLiteObjectArray::RemoveL

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

//

EXPORT_C void CUpnpCdsLiteObjectArray::RemoveL( const CUpnpObject *aObject )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::RemoveL" );

    // First, create a new CreateUpnpCdsLiteObject

    CUpnpCdsLiteObject* object = CreateUpnpCdsLiteObjectL( aObject );

    CleanupStack::PushL( object );

    // Search the array and remove the object if found

    TInt index = FindByObjectId( object->ObjectId() );

    if( index >= 0 )

        {

        RemoveObjectAtL( index );

        }

    // Clean up

    CleanupStack::PopAndDestroy( object );

    }

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

// CUpnpCdsLiteObjectArray::CreateUpnpCdsLiteObjectL

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

//

CUpnpCdsLiteObject* CUpnpCdsLiteObjectArray::CreateUpnpCdsLiteObjectL(

                                                const CUpnpObject *aObject )

    {

    // Check the param

    if( !aObject )

        {

        User::Leave( KErrArgument );

        }

    CUpnpCdsLiteObject* object = NULL;

    // Object is a container

    if( aObject->ObjectClass().Find( KContainerClass() ) >= 0 )

        {

        // Cast to container object

        CUpnpContainer* container = (CUpnpContainer*)aObject;

        // Create the object accordingly

        object = CUpnpCdsLiteObject::NewL( container->Title(),

                                           CUpnpCdsLiteObject::EContainer,

                                           container->Id(),

                                           container->ParentId(),

                                           container->ObjectClass() );

        CleanupStack::PushL( object );

        }

    // Object is an item / reference item

    else if( aObject->ObjectClass().Find( KItemClass() ) >= 0 )

        {

        // Cast to container object

        CUpnpItem* item = (CUpnpItem*)aObject;

        HBufC8* fileName = NULL;

        // Resolve the type

        CUpnpCdsLiteObject::TCdsLiteObjectType type =

                                    CUpnpCdsLiteObject::EUnknown;

        if( item->RefId() == KNullDesC8 )

            {

            type = CUpnpCdsLiteObject::EItem;

            fileName = ResolveFileNameL( aObject );

            CleanupStack::PushL( fileName );

            }

        else

            {

            type = CUpnpCdsLiteObject::EItemReference;

            // Set space for reference filename.

            // Item validation requires that CDS lite object's name field must

            // be different that KNullDesC8.

            // Mediaserver doesn't store this field for reference item and it

            // is KNullDesC8 when structrure is read from server.

            fileName = KSpace().AllocLC();

            }

        // Create the object accordingly

        object = CUpnpCdsLiteObject::NewL( *fileName,

                                           type,

                                           item->Id(),

                                           item->ParentId(),

                                           item->ObjectClass() );

        if ( fileName )

            {

            CleanupStack::PopAndDestroy( fileName );    

            }

        CleanupStack::PushL( object );

        // Set the reference ID, if necessary

        if( type == CUpnpCdsLiteObject::EItemReference )

            {

            object->SetOriginalItemIdL( item->RefId() );

            }

        }

    // Object is neither a container nor an item, leave

    else

        {

        User::Leave( KErrArgument );

        }

    CleanupStack::Pop( object );

    return object;

    }

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

// CUpnpCdsLiteObjectArray::ResolveFileNameL

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

//

HBufC8* CUpnpCdsLiteObjectArray::ResolveFileNameL(

                                        const CUpnpObject *aObject )

    {

    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsLiteObjectArray::\

ResolveFileNameL" );

    // Check parameter

    if( !aObject )

        {

        User::Leave( KErrArgument );

        }

    HBufC8* returnValue = NULL;

    // Get all the elements

    const RUPnPElementsArray& elements =

                    ( const_cast<CUpnpObject*>(aObject) )->GetElements();

    // Find the "res" element

    for( TInt index=0; index<elements.Count(); index++ )

        {

        if( elements[index]->Name() == KElementRes )

            {

            // Parse the filename

            TParse fp;

            fp.Set( elements[index]->FilePath(), 0, 0 );

            // Full filename (path and drive letter included)

            returnValue =

                EscapeUtils::ConvertFromUnicodeToUtf8L( fp.FullName() );

            // Exit the loop

            index = elements.Count() + 1;

            }

        }

    return returnValue;

    }

// End of file