/*
* Copyright (c) 2008 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:      CUpnpContentShareAO class implementation
*
*/






// INCLUDE FILES

#include "upnpcontentshareao.h"
#include "upnpfilesharingengine.h"

_LIT( KComponentLogfile, "applicationengine.txt");
#include "upnplog.h"

// --------------------------------------------------------------------------
// CUpnpContentShareAO::CUpnpContentShareAO
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUpnpContentShareAO::CUpnpContentShareAO( 
    CUPnPFileSharingEngine& aEngine,
    RUpnpContentServerClient& aContentServer ):
    CActive( CActive::EPriorityStandard ),
    iEngine( aEngine ),
    iContentServer( aContentServer )
    {
    CActiveScheduler::Add( this );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::ConstructL()
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::ConstructL()
    {    
    __LOG( "CUpnpContentShareAO::ConstructL" );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::NewL
// --------------------------------------------------------------------------
//
CUpnpContentShareAO* CUpnpContentShareAO::NewL( 
        CUPnPFileSharingEngine& aEngine, 
        RUpnpContentServerClient& aContentServer )
    {   
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::NewL begin" );
    CUpnpContentShareAO* self = CUpnpContentShareAO::NewLC(
            aEngine, aContentServer );
    CleanupStack::Pop( self );
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::NewL end" );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::NewLC
// --------------------------------------------------------------------------
//
CUpnpContentShareAO* CUpnpContentShareAO::NewLC( 
        CUPnPFileSharingEngine& aEngine, 
        RUpnpContentServerClient& aContentServer )
    {    
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::NewLC begin" );
    CUpnpContentShareAO* self = new( ELeave )
        CUpnpContentShareAO( aEngine, aContentServer );
    CleanupStack::PushL( self );
    self->ConstructL();
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::NewLC end" );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::~CUpnpContentShareAO()
// Destructor
// --------------------------------------------------------------------------
//    
CUpnpContentShareAO::~CUpnpContentShareAO()
    {
    __LOG( "CUpnpContentShareAO::~CUpnpContentShareAO " );

    iQueuedSelections.ResetAndDestroy();
    iQueuedSelections.Close();
    iQueuedTypes.Close();

    Cancel();
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::ChangeSharedContentL()
// Sends the selected indexes to server and starts sharing
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::ChangeSharedContentL(
    UpnpContentServer::TUpnpMediaType aType,
    const CArrayFix<TInt>& aMarkedItems )
    {   
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::\
ChangeSharedContentL begin" );

    if ( !IsActive() )
        {
        __ASSERTD( iQueuedTypes.Count() == 0, __FILE__, __LINE__ );
        iContentServer.ChangeSharedContentL( aType, aMarkedItems, iStatus );
        iStatus = KRequestPending;
        SetActive();       
        }
    else
        {
        //remove all queued requests with this type
        RemoveQueuedObjectByType( aType );
        
        //queue this request
        CArrayFix<TInt>* selections = 
            new ( ELeave ) CArrayFixFlat<TInt>( aMarkedItems.Count() );
        CleanupStack::PushL( selections );
        for ( TInt i ( 0 ); i < aMarkedItems.Count(); i++ )
            {
            selections->AppendL( aMarkedItems.At(i) );
            }
        
        AppendQueuedObjectL( aType, selections );
        CleanupStack::Pop( selections );
        __ASSERTD( iQueuedSelections.Count() == iQueuedTypes.Count(),
                __FILE__, __LINE__ );
        }

    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::\
ChangeSharedContentL end" );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::RefreshSharedContentL()
// Updates shared objects in mediaserver
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::RefreshSharedContentL( 
    UpnpContentServer::TUpnpMediaType aType )
    {
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::\
RefreshSharedContentL begin" );
    if ( !IsActive() )
        {
        __ASSERTD( iQueuedTypes.Count() == 0, __FILE__, __LINE__ );
        iContentServer.RefreshSharedContentL( aType, iStatus );       
        iStatus = KRequestPending;
        SetActive();       
        }
    else
        {
        //remove all queued requests with this type
        RemoveQueuedObjectByType( aType );

        //queue this request
        CArrayFix<TInt>* selections( NULL );
        AppendQueuedObjectL( aType, selections );
        __ASSERTD( iQueuedSelections.Count() == iQueuedTypes.Count(),
                __FILE__, __LINE__ );
        }
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::\
RefreshSharedContentL end" );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::DoCancel
// Cancel the operation
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::DoCancel()
    {    
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::DoCancel" );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::RunL
// Function is called when active request is ready
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::RunL()
    {      
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::RunL begin" );
    __LOG1( "[UPNP_ENGINE]\t\t status: %d", iStatus.Int() );

    TInt err = iStatus.Int();
    if ( err && 
         err != KErrServerBusy )
        {
        // KErrServerBusy is a response to the 
        // CUpnpContentServer::RefreshSharedContentL call. Therefore we must 
        // not leave without cleaning queued objects. 
        // Otherwise next call to CUpnpContentShareAO::RefreshSharedContentL 
        // will panic (in UDEB builds only!!!!). 
        
        // Clears queued objects and leaves.
        iQueuedSelections.ResetAndDestroy();
        iQueuedTypes.Reset();
        User::Leave( err );
        }

    //When get the responce from the content server then change the UI    
    iEngine.RequestSharingProgressL();

    if ( iQueuedTypes.Count() )
        {
        // Get next queued objects
        UpnpContentServer::TUpnpMediaType type = iQueuedTypes[ 0 ];
        CArrayFix<TInt>* selections = iQueuedSelections[ 0 ];
        
        // Clear arrays.
        iQueuedSelections.Remove( 0 );
        iQueuedTypes.Remove( 0 );
        
        if ( selections )
            {
            //share request
            CleanupStack::PushL( selections );
            iContentServer.ChangeSharedContentL( type, *selections, iStatus );
            CleanupStack::PopAndDestroy( selections );
            }
        else
            {
            //refresh request
            iContentServer.RefreshSharedContentL( type, iStatus );       
            }
        
        iStatus = KRequestPending;
        SetActive();       
        }
    __LOG( "[UPNP_ENGINE]\t CUpnpContentShareAO::RunL end" );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::RunError
// Handles a leave occurring in the request completion
// --------------------------------------------------------------------------
//
TInt CUpnpContentShareAO::RunError( TInt aError )
    {    
    __LOG( "CUpnpContentShareAO::RunError" );
    if ( iEngine.Observer() )
        {
        iEngine.Observer()->HandleSharingDone( iEngine, aError );
        }
    return KErrNone;
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::RemoveQueuedObjects
// Removed queued objects by index.
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::RemoveQueuedObject( TInt aIndex )
    {
    // Checks argument in udeb build.
    // USER 130 panic will occure in urel builds if argument is
    // incorrent.
    TInt count = iQueuedTypes.Count();
    __ASSERTD( aIndex >= 0 && aIndex < iQueuedTypes.Count(),
            __FILE__, __LINE__ );
    
    iQueuedTypes.Remove( aIndex );
    if ( iQueuedSelections[ aIndex ] )
        {
        delete iQueuedSelections[ aIndex ];
        }
    iQueuedSelections.Remove( aIndex );
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::RemoveQueuedObjectByType
// Removed queued objects by type.
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::RemoveQueuedObjectByType( 
        UpnpContentServer::TUpnpMediaType aType )
    {
    //remove all queued requests with this type
    for ( TInt i( iQueuedTypes.Count() - 1 ); i >= 0; i-- )
        {
        if ( iQueuedTypes[ i ] == aType )
            {
            RemoveQueuedObject( i );
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpContentShareAO::AppendQueuedObjectL
// Appends given objects.
// --------------------------------------------------------------------------
//
void CUpnpContentShareAO::AppendQueuedObjectL( 
        UpnpContentServer::TUpnpMediaType aType, 
        CArrayFix<TInt>* aSelections )
    {
    iQueuedTypes.AppendL( aType );
    TRAPD( err, iQueuedSelections.AppendL( aSelections ) );
    if ( err )
        {
        // Couldn't append array to the iQueuedSelections array.
        // Removes the type and leaves.
        iQueuedTypes.Remove( iQueuedTypes.Count() - 1 );
        User::Leave( err );
        }
    }