/**
 * 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:  CUpnpCdsReaderAO class implementation
 *
 */

// INCLUDES
#include <upnpfilesharing.h>
#include <upnpobject.h>

#include "upnpcdsreaderao.h"
#include "upnpsharingalgorithmconstants.h"
#include "upnplog.h"
#include "upnpcommonutils.h"
#include "upnpcdsliteobjectarray.h"
#include "upnpbrowsecriteria.h"
#include "upnpcontainerlist.h"
#include "upnpitemlist.h"

const TInt KDefaultBrowseReqCount( 50 );
const TInt KLoopLimit( 3 );

// --------------------------------------------------------------------------
// CUpnpSecAccessController::NewL
// --------------------------------------------------------------------------
//
CUpnpCdsReaderAO* CUpnpCdsReaderAO::NewL(
    CUpnpCdsLiteObjectArray& aUpnpCdsLiteObjects )
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::NewL" );

    CUpnpCdsReaderAO* self = new ( ELeave ) CUpnpCdsReaderAO(
        aUpnpCdsLiteObjects );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::ConstructL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::ConstructL()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::ConstructL" );

    if ( !CActiveScheduler::Current() )
        {
        iScheduler = new ( ELeave ) CActiveScheduler;
        CActiveScheduler::Install( iScheduler );
        }
    // Add this active object to the active scheduler.
    CActiveScheduler::Add( this );

    iFileSharing = CUpnpFileSharing::NewL();
    iWaitRequest = new ( ELeave ) CActiveSchedulerWait();
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::~CUpnpCdsReaderAO
// --------------------------------------------------------------------------
//
CUpnpCdsReaderAO::~CUpnpCdsReaderAO()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::~CUpnpCdsReaderAO" );

    delete iFileSharing;
    delete iWaitRequest;

    if ( CActiveScheduler::Current() == iScheduler )
        {
        CActiveScheduler::Install( NULL );
        }
    delete iScheduler;
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::ReadCdsStructureL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::ReadCdsStructureL()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::ReadCdsStructureL" );

    // Start reading from root container
    GetContainersL( KRootContainer );
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::GetContainersL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::GetContainersL( const TDesC8& aContainerId )
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::GetContainersL" );

    // Get all items of container with id aContainerId
    GetItemsL( aContainerId );

    // Number of found items. Count is initialized as KDefaultBrowseReqCount
    // to get into the while loop. Loop ends, when GetSharedItemListL
    // request does not get new objects
    TInt count( KDefaultBrowseReqCount );
    TInt startingIndex( 0 );
    TInt loopCounter( 0 );

    while ( startingIndex < count )
        {
        count = 0;

        CUpnpContainerList* containerList = CUpnpContainerList::NewL();
        CleanupStack::PushL( containerList );

        CUpnpBrowseCriteria* browseCriteria = CUpnpBrowseCriteria::NewLC();
        browseCriteria->SetRequestedCount( KDefaultBrowseReqCount );
        browseCriteria->SetStartingIndex( startingIndex );
        browseCriteria->SetFilterL( KBrowseCriteriaFilter );

        // Query all items and containers with container id aContainerId
        iFileSharing->GetSharedContainerListL(
            UPnPCommonUtils::DesC8ToInt( aContainerId ),
            *browseCriteria,
            *containerList,
            count,
            iStatus );

        CleanupStack::PopAndDestroy( browseCriteria );

        // Wait for the request to complete
        CompleteRequestL();

        // Leave, if GetSharedContainerListL gives continuously zero items
        if ( !containerList->ObjectCount() )
            {
            loopCounter += 1;
            if ( loopCounter >= KLoopLimit )
                {
                User::Leave( KErrGeneral );
                }
            }
        else
            {
            loopCounter = 0;
            }

        for ( TInt index( 0 ); index < containerList->ObjectCount(); index++ )
            {
            // Append container to the objects array
            iUpnpCdsLiteObjects.AppendL( ( *containerList )[ index ] );
            // Call object search recursively for each found container
            GetContainersL( ( *containerList )[ index ]->Id() );
            }

        startingIndex += containerList->ObjectCount();

        CleanupStack::PopAndDestroy( containerList );
        }
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::GetItemsL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::GetItemsL( const TDesC8& aContainerId )
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::GetItemsL" );

    // Number of found items. Count is initialized as KDefaultBrowseReqCount
    // to get into the while loop. Loop ends, when GetSharedItemListL
    // request does not get new objects
    TInt count( KDefaultBrowseReqCount );
    TInt startingIndex( 0 );
    TInt loopCounter( 0 );

    while ( startingIndex < count )
        {
        count = 0;

        CUpnpItemList* itemList = CUpnpItemList::NewL();
        CleanupStack::PushL( itemList );

        CUpnpBrowseCriteria* browseCriteria = CUpnpBrowseCriteria::NewLC();
        browseCriteria->SetRequestedCount( KDefaultBrowseReqCount );
        browseCriteria->SetStartingIndex( startingIndex );
        browseCriteria->SetFilterL( KBrowseCriteriaFilter );

        // Query all items of container with container id aContainerId
        iFileSharing->GetSharedItemListL(
            UPnPCommonUtils::DesC8ToInt( aContainerId ),
            *browseCriteria,
            *itemList,
            count,
            iStatus );

        CleanupStack::PopAndDestroy( browseCriteria );

        // Wait for the request to complete
        CompleteRequestL();

        // Leave, if GetSharedContainerListL gives continuously zero items
        if ( !itemList->ObjectCount() )
            {
            loopCounter += 1;
            if ( loopCounter >= KLoopLimit )
                {
                User::Leave( KErrGeneral );
                }
            }
        else
            {
            loopCounter = 0;
            }

        // Append files to the objects array
        for ( TInt index( 0 ); index < itemList->ObjectCount(); index++ )
            {
            // Local media applications store temporary items under
            // root container. Therefore items whose parent container
            // is root, are not appended to the objects array.
            if ( ( *itemList )[ index ]->ParentId().Match( KRootContainer )
                == KErrNotFound )
                {
                iUpnpCdsLiteObjects.AppendL( ( *itemList )[ index ] );
                }
            }

        startingIndex += itemList->ObjectCount();

        CleanupStack::PopAndDestroy( itemList );
        }
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::RunL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::RunL()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::RunL" );

    // Request completed - no need to wait anymore
    // Let ao caller to continue
    StopWaitingRequestComplete();
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::DoCancel
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::DoCancel()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::DoCancel" );

    Cancel();
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::WaitRequestToComplete
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::WaitRequestToComplete()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::\
WaitRequestToComplete" );

    // Wait for a request to complete
    if ( iWaitRequest && !iWaitRequest->IsStarted() )
        {
        iWaitRequest->Start();
        }
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::StopWaitingRequestComplete
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::StopWaitingRequestComplete()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::\
StopWaitingRequestComplete" );

    // Stop waiting process after query has been completed
    if ( iWaitRequest && iWaitRequest->IsStarted() )
        {
        iWaitRequest->AsyncStop();
        }
    }

// --------------------------------------------------------------------------
// CUpnpCdsReaderAO::CompleteRequestL
// --------------------------------------------------------------------------
//
void CUpnpCdsReaderAO::CompleteRequestL()
    {
    __LOG( "[CUpnpSharingAlgorithm]\t CUpnpCdsReaderAO::\
CompleteRequestL" );

    if ( !IsActive() )
        {
        SetActive();
        }
    else
        {
        User::Leave( KErrInUse );
        }

    // Wait for request to complete
    WaitRequestToComplete();

    // Leave if error happens
    if ( iStatus.Int() != KErrNone &&
         iStatus.Int() != KErrNotFound )
        {
        User::Leave( iStatus.Int() );
        }
    }

//  End of File