/*

* Copyright (c) 2006-2007 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:      Content sharing servers main scheduler function

 *

*/

#include <e32debug.h>

#include <e32property.h>

#include "upnpcommonutils.h"

#include "upnpcontentserverdefs.h"

#include "upnpcontentserverhandler.h"

#include "upnpselectionreader.h"

#include "upnpcontentserverclient.h"

#include "upnpcontainercheckerao.h"

#include "upnpcontentserver.h"

#include "upnpperiodic.h"

_LIT( KComponentLogfile, "contentserver.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KNoProgress = 0;

const TInt KMaxProgress = 100;

const TInt KRequestBufferSize = 2;

using namespace UpnpContentServer;

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

// CUpnpContentServerHandler::NewL

// 2-phased constructor.

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

//

CUpnpContentServerHandler* CUpnpContentServerHandler::NewL(

    CUpnpContentServer* aServer )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpContentServerHandler* self =

        new (ELeave) CUpnpContentServerHandler( aServer );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    return self;

    }

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

// CUpnpContentServerHandler::CUpnpContentServerHandler()

// C++ constructor.

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

//

CUpnpContentServerHandler::CUpnpContentServerHandler(

    CUpnpContentServer* aServer ) :

    iServer( aServer ),

    iContentSharingObserver( NULL ),

    iDefaultContainerIds( 3 )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    iHandlerState = ENotActive;

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::ConstructL

// 2nd phase constructor.

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

//

void CUpnpContentServerHandler::ConstructL()

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    static _LIT_SECURITY_POLICY_S0(KThisProcessPolicy,

                                   KUpnpContentServerCat.iUid );

    // define progress property to be a byte array, allocating mem

    TInt err = iProgressProperty.Define( KUpnpContentServerCat,

                                         ESharingProgress,

                                         RProperty::EByteArray,

                                         KAllowAllPolicy,

                                         KThisProcessPolicy,

                                         sizeof( TUpnpProgress ) );

    if ( err != KErrNone )

        {

        __LOG1( "Error: %d", err );

        }

    if ( err!=KErrAlreadyExists )

        {

        User::LeaveIfError( err );

        }

    iIdle = CUPnPPeriodic::NewL( CActive::EPriorityIdle );

    TCallBack cb( RefreshClfL, this );

    const TInt KRefreshDelay( 500000 );

    iIdle->Start( KRefreshDelay, KRefreshDelay, cb );

    iReader = CUpnpSelectionReader::NewL( NULL ); // metadata set later

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::RefreshClfL

// ( other items are commented in header )

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

//

TInt CUpnpContentServerHandler::RefreshClfL( TAny* aPtr )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpContentServerHandler* handler( NULL );

    handler = static_cast<CUpnpContentServerHandler*>( aPtr );

    handler->iMetadata = CUpnpContentMetadataUtility::NewL();

    handler->iMetadata->SetCallback( handler );

    handler->iReader->SetMetadata( handler->iMetadata );

    handler->iIdle->Cancel();

    delete handler->iIdle;

    handler->iIdle = NULL;

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    return KErrNone;

    }

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

// CUpnpContentServerHandler::~CUpnpContentServerHandler()

// C++ destructor.

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

//

CUpnpContentServerHandler::~CUpnpContentServerHandler()

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    delete iAo;

    delete iUnsharer;

    delete iContainerChecker;

    delete iMetadata;

    delete iReader;

    delete iMediaServer;

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    iDefaultContainerIds.Close();

    delete iPendingSharingReq;

    delete iMusicSharingReq;

    delete iVisualSharingReq;

    iProgressProperty.Delete( KUpnpContentServerCat, ESharingProgress );

    iProgressProperty.Close();

    iServer = NULL;

    if ( iIdle )

        {

        iIdle->Cancel();

        delete iIdle;

        }

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::SetContentSharingObserverL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::SetContentSharingObserverL(

    MUpnpContentSharingObserver* aObserver )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    iContentSharingObserver = aObserver; // can be NULL

    if( iContentSharingObserver )

        {

        SetProgressL( KNoProgress );

        }

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::GetSelectionContentL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::GetSelectionContentL(

    const TInt& aContainerType )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    // There might be many containers -> 10 is OK for granularity

    CDesCArray* containers = new ( ELeave ) CDesCArrayFlat( 10 );

    CleanupStack::PushL( containers );

    if ( iMetadata->RefreshOngoing() )

        {

        if ( !iWait.IsStarted() )

            {

            iWait.Start();

            }

        else

            {

            __LOG1( "Error: %d", __LINE__ );

            }

        }

    switch ( aContainerType )

        {

    case EImageAndVideo :

        {

        iReader->FetchCollectionsL( containers );

        }

        break;

    case EPlaylist :

        {

        iReader->FetchPlaylistsL( containers );

        }

        break;

    default :

        {

        CleanupStack::PopAndDestroy( containers );

        __LOG1( "Error: %d", __LINE__ );

        }

        break;

        }

    if ( iContentSharingObserver )

        {

        iContentSharingObserver->CompleteSelectionContentL( *containers );

        }

    CleanupStack::PopAndDestroy( containers );

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::GetSelectionIndexesL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::GetSelectionIndexesL(

    RArray<TInt>& aMarkedItems,

    const TInt aType )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpSharingRequest* sharingReq( NULL );

    switch ( aType )

        {

    case EImageAndVideo :

        {

        if ( iVisualSharingReq )

            {

            sharingReq = iVisualSharingReq;

            }

        }

        break;

    case EPlaylist :

        {

        if ( iMusicSharingReq )

            {

            sharingReq = iMusicSharingReq;

            }

        }

        break;

    default :

        {

        __LOG1( "Error: %d", __LINE__ );

        }

        break;

        }

    if ( sharingReq )

        {

        // There is sharing ongoing, return the buffered selections

        for( TInt i(0); i < sharingReq->iSelections.Count(); i++ )

            {

            }

        }

    else

        {

        if ( !iReader )

            {

            __LOG1( "Error: %d", __LINE__ );

            iReader = CUpnpSelectionReader::NewL( iMetadata );

            }

        iReader->GetSelectionIndexesL( aMarkedItems, (TUpnpMediaType)aType );

        }

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::ChangeShareContentL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::ChangeShareContentL(

    const RArray<TInt>& aMarkedItems,

    const TInt aType )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    for( TInt e(0); e<aMarkedItems.Count();e++)

        {

        __LOG2("CUpnpContentServerHandler: received index[%d] = %d",

            e, aMarkedItems[e] );

        }

    switch ( iHandlerState )

        {

    case ESchedulingSharing :

        {

        if ( aType == iBufferPosition )

            {

            if ( iSharingPhase != EShare )

                {

                SetSharingRequestL( aMarkedItems, aType );

                }

            else // iSharingPhase == EShare

                {

                // sanity checks

                delete iUnsharer;

                iUnsharer = NULL;

                delete iContainerChecker;

                iContainerChecker = NULL;

                if ( iAo )

                    {

                    // iAo cannot be deleted here, request stop instead

                    iAo->RequestStop(

                        MUpnpSharingCallback::ESharingFullStop );

                    }

                // Get playlist Ids

                CDesCArray* ids = new (ELeave) CDesCArrayFlat(4);

                CleanupStack::PushL( ids );

                CDesCArray* names = new (ELeave) CDesCArrayFlat(4);

                CleanupStack::PushL( names );

                if ( aType == EImageAndVideo )

                    {

                    iReader->CollectionIdsL( *ids, *names );

                    }

                else

                    {

                    iReader->PlayListIdsL( *ids, *names );

                    }

                // pendingSharingReq will be handled from callback

                delete iPendingSharingReq;

                iPendingSharingReq = NULL;

                iPendingSharingReq = CUpnpSharingRequest::NewL( aType,

                                                                aMarkedItems,

                                                                ids,

                                                                names );

                CleanupStack::Pop( names ); // ownership transferred

                CleanupStack::Pop( ids ); // ownership transferred

                }

            }

        else

            {

            SetSharingRequestL( aMarkedItems, aType );

            }

        }

        break;

    case ENotActive :

        {

        delete iMetadata;

        iMetadata = NULL;

        iMetadata = CUpnpContentMetadataUtility::NewL();

        iMetadata->SetCallback( this );

        iReader->SetMetadata( iMetadata );

        if ( iMetadata->RefreshOngoing() )

            {

            __LOG("CUpnpContentServerHandler: Waiting refresh 3");

            iWait.Start();

            }

        SetSharingRequestL( aMarkedItems, aType );

        iBufferPosition = aType;

        // Start sharing

        iHandlerState = ESchedulingSharing;

        iSharingPhase = ECheckDefaults;

        // start the sharing

        DoShareL();

        }

        break;

    default :

        {

        __LOG1( "Error: %d", __LINE__ );

        }

        break;

        }

    SetProgressL( KNoProgress );

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::RefreshShareContentL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::RefreshShareContentL(

    TInt aType )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    if ( ( aType == EImageAndVideo && iVisualSharingReq ) ||

         ( aType == EPlaylist && iMusicSharingReq ) )

        {

        // no refresh available if sharing is ongoing

        __LOG1( "Error: %d", __LINE__ );

        User::Leave( KErrServerBusy );

        }

    if ( iMetadata->RefreshOngoing() )

        {

        __LOG("CUpnpContentServerHandler: Waiting refresh 1");

        iWait.Start();

        }

    delete iReader;

    iReader = NULL;

    iReader = CUpnpSelectionReader::NewL( iMetadata );

    RArray<TInt> selectedItems;

    CleanupClosePushL( selectedItems );

    CDesCArray* containers = new ( ELeave ) CDesCArrayFlat( 10 );

    CleanupStack::PushL( containers );

    iReader->FetchCollectionsL( containers );

    GetSelectionIndexesL( selectedItems, aType );

    CDesCArray* ids = new (ELeave) CDesCArrayFlat(4);

    CleanupStack::PushL( ids );

    CDesCArray* names = new (ELeave) CDesCArrayFlat(4);

    CleanupStack::PushL( names );

    iReader->CollectionIdsL( *ids, *names );

    if ( aType == EImageAndVideo )

        {

        iVisualSharingReq = CUpnpSharingRequest::NewL( aType,

                                                       selectedItems,

                                                       ids,

                                                       names );

        }

    else if ( aType == EPlaylist )

        {

        iMusicSharingReq = CUpnpSharingRequest::NewL( aType,

                                                      selectedItems,

                                                      ids,

                                                      names );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    CleanupStack::Pop( names ); // ownership transferred

    CleanupStack::Pop( ids ); // ownership transferred

    ChangeShareContentL( selectedItems, aType );

    selectedItems.Reset();

    containers->Reset();

    CleanupStack::PopAndDestroy( containers );

    CleanupStack::PopAndDestroy( &selectedItems );

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );

    }

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

// CUpnpContentServerHandler::FillProgressInfoL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::FillProgressInfoL(

    RArray<TUpnpProgressInfo>& aArr,

    const TInt aType )

    {

    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpSharingRequest* sharingReq( NULL );

    if( iPendingSharingReq && iPendingSharingReq->iKind == aType )

        {

        sharingReq = iPendingSharingReq;

        }

    else

        {

        if ( aType == EImageAndVideo )

            {

            sharingReq = iVisualSharingReq;

            }

        else if ( aType == EPlaylist )

            {

            sharingReq = iMusicSharingReq;

            }

        }

    TUpnpProgressInfo progress;

    progress.iProgressKind = UpnpContentServer::TUpnpMediaType( aType );

    if ( sharingReq )

        {

        progress.iProgressType = TUpnpProgressInfo::ESharingProgress;

        if ( iBufferPosition == aType &&

             iHandlerState == ESchedulingSharing &&

             ( iAo || iUnsharer || iContainerChecker ))

            {

            // sharing ongoing for images

            TInt prog ( 0 );

            TInt progRel( 0 );

            if ( iAo && iSharingPhase == EShare )

                {

                prog = iAo->SharingProgress(

                    (TUpnpMediaType&)progress.iProgressKind );

                progRel = ( prog * KMaxProgress ) / sharingReq->iItemCount;      

                }

            if ( iUnsharer &&  iSharingPhase == EUnshare  )

                {

                prog = iUnsharer->UnSharingProgress();

                TInt itemNum = iUnsharer->TotalItemsForUnShare();

                if( itemNum > 0 )

                    {     

                    progRel = ( prog * KMaxProgress ) / itemNum;          

                    }

                }