/*

* 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 "upnpsharingalgorithmfactory.h"

#include "upnpcdsliteobject.h"

#include "upnpcdsliteobjectarray.h"

#include <mclfitemlistmodel.h>

#include <escapeutils.h>            // ConvertFromUnicodeToUtf8L

#include "upnpcommonutils.h"

#include "upnpcontentserverdefs.h"

#include "upnpcontentserverhandler.h"

#include "upnpselectionreader.h"

#include "upnpcontentserverclient.h"

#include "upnpcontentserver.h"

#include "upnpcontentmetadatautility.h"

_LIT( KComponentLogfile, "contentserver.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KNoProgress = -1;

const TInt KZeroProgress = 0;

const TInt KArrayGranularity = 10;

_LIT8( KAudio, "audio" );

_LIT8( KVideo, "video" );

_LIT8( KImage, "image" );

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 ),

    iOngoingSharingType( KErrNotFound ),

    iErrorToClient( KErrNone ),

    iSharingAlgorithm( NULL )

    {

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

    ResetPendingRequestInfo();

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

    }

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

// CUpnpContentServerHandler::ConstructL

// 2nd phase constructor.

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

//

void CUpnpContentServerHandler::ConstructL()

    {

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

    static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

    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 );

        }

    // Create selection reader

    iReader = CUpnpSelectionReader::NewL();

    // reset progress information

    SetProgressL( KNoProgress );

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

    }

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

// CUpnpContentServerHandler::InitializeL

// ( other items are commented in header )

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

//

void CUpnpContentServerHandler::InitializeL()

    {

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

    // Create MUpnpSharingAlgorithm

    if ( !iSharingAlgorithm )

        {

        iSharingAlgorithm = 

                CUPnPSharingAlgorithmFactory::NewSharingApiL();

        }

    // Create CUpnpContentSharerAo

    if ( !iAo )

        {

        iAo = CUpnpContentSharerAo::NewL( this, iSharingAlgorithm );

        }

    // Create CUpnpContentMetadataUtility

    if ( !iMetadata )

        {

        iMetadata = CUpnpContentMetadataUtility::NewL();

        }

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

    }

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

// CUpnpContentServerHandler::~CUpnpContentServerHandler()

// C++ destructor.

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

//

CUpnpContentServerHandler::~CUpnpContentServerHandler()

    {

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

    if ( iSharingAlgorithm )

        {

        iSharingAlgorithm->Close();

        }

    delete iAo;

    delete iMetadata;

    delete iReader;

    delete iMediaServer;

    iPendingSharingReqInfo.iMarkedItems.Close();

    delete iMusicSharingReq;

    delete iVisualSharingReq;

    iProgressProperty.Delete( KUpnpContentServerCat, ESharingProgress );

    iProgressProperty.Close();

    iServer = NULL;

    __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

    __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( KArrayGranularity );

    CleanupStack::PushL( containers );

    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 && 

        sharingReq->iClfIds && 

        sharingReq->iSharingType == EShareMany )

        {

        // There is sharing ongoing, return the buffered selections

        for( TInt i(0); i < sharingReq->iClfIds->MdcaCount(); i++ )

            {

            TInt index = iReader->GetSelectionIndexL( 

                    (TUpnpMediaType)aType, 

                    sharingReq->iClfIds->MdcaPoint( i ) );

            if ( index != KErrNotFound )

                {

                aMarkedItems.AppendL( index );

                }

            }

        }

    else

        {

        if ( !iReader )

            {

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

            iReader = CUpnpSelectionReader::NewL();

            }

        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] );

        }    

    if ( iOngoingSharingType != KErrNotFound )

        {

        // sharing process ongoing, check that if selection is changed

        // to ongoing sharing type

        if ( aType == iOngoingSharingType && iAo->SharingOngoing() )

            {

            // save pending request info

            SavePendingRequestInfoL( aMarkedItems, aType );

            // cancel Ao and create new sharing request in callback

            iAo->StopSharing();

            }

        else

            {

            SetSharingRequestL( aMarkedItems, aType );

            }

        }

    else

        {

        // Not active, ie. no sharing ongoing        

        SetSharingRequestL( aMarkedItems, aType );

        iOngoingSharingType = aType;

        // start the sharing

        DoShare();

        }

    __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 );

        }

    delete iReader;

    iReader = NULL;

    iReader = CUpnpSelectionReader::NewL();

    if ( aType == EImageAndVideo )

        {

        RArray<TInt> markedItems;

        CleanupClosePushL( markedItems );

        // Get selected indexes and create new sharing request

        GetSelectionIndexesL( markedItems, aType );

        SetSharingRequestL( markedItems, aType );

        CleanupStack::PopAndDestroy( &markedItems );

        }

    else if ( aType == EPlaylist )

        {

        RArray<TInt> markedItems;

        CleanupClosePushL( markedItems );

        // Get selected indexes and create new sharing request

        GetSelectionIndexesL( markedItems, aType );

        SetSharingRequestL( markedItems, aType );

        CleanupStack::PopAndDestroy( &markedItems );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    // if no refreshes ongoing, start sharing

    if ( iOngoingSharingType == KErrNotFound )

        {

        iOngoingSharingType = aType;

        DoShare();

        }

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

    }

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

// CUpnpContentServerHandler::CanStop

// ( other items are commented in header )

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

//

TBool CUpnpContentServerHandler::CanStop() const

    {

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

    TBool ret( EFalse );

    if ( !( iVisualSharingReq || iMusicSharingReq  ) )

        {

        __LOG("CUpnpContentServerHandler: CanStop(): 1");

        ret = ETrue;

        }

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

    return ret;

    }

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

// CUpnpContentServerHandler::CompleteSharingOperationL

// This should be called from active objects owned by handler

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

//

void CUpnpContentServerHandler::CompleteSharingOperationL(

    const TInt& aErr, const TInt& aType )

    {

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

    switch ( aErr )

        {

        case KErrNone:

            {

            iErrorToClient = KErrNone;

            if ( aType == EImageAndVideo )

                {

                // Reset sharing request object 

                delete iVisualSharingReq;

                iVisualSharingReq = NULL;

                // If there is pending music request, process it next 

                if ( iMusicSharingReq )

                    {

                    iOngoingSharingType = EPlaylist;

                    DoShare();

                    }

                else

                    {

                    iOngoingSharingType = KErrNotFound;

                    }

                }

            else if ( aType == EPlaylist )

                {

                // Reset sharing request object 

                delete iMusicSharingReq;

                iMusicSharingReq = NULL;

                // If there is pending music request, process it next 

                if ( iVisualSharingReq )

                    {

                    iOngoingSharingType = EImageAndVideo;

                    DoShare();

                    }

                else

                    {

                    iOngoingSharingType = KErrNotFound;

                    }

                }

            else 

                {

                iOngoingSharingType = KErrNotFound;

                }

            break;

            }

        case KErrCancel:

            {

            // User reselected currently ongoing sharing, handle it next

            if ( iPendingSharingReqInfo.iMarkedItems.Count() )

                {

                // create sharing request from pending info

                TRAPD( 

                    err, 

                    SetSharingRequestL( 

                        iPendingSharingReqInfo.iMarkedItems,

                        iPendingSharingReqInfo.iMediaType ) 

                    );

                if ( err )

                    {

                    HandleError( err );

                    }