/*

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

 *

*/

//  Include Files

#include <upnpcontainer.h>

#include <upnpfilesharing.h>

#include <upnpcontainer.h>

#include <upnpitem.h>

#include <upnpitemlist.h>

#include <upnpobject.h>

#include <upnpstring.h>

#include <s32file.h>

#include <f32file.h>

#include "upnpcommonutils.h" // FindContainerByTitle

#include "upnpcdsreselementutility.h"

// CLF headers

#include <MCLFContentListingEngine.h>

#include <ContentListingFactory.h>

#include <MCLFItemListModel.h>

#include <CLFContentListing.hrh>

//#include <clfcontentlistingextended.hrh>

#include <MCLFItem.h>

#include "upnpcontentsharingao.h"

#include "upnpcontentmetadatautility.h"

#include "upnpselectionwriter.h"

#include "upnpcontainercheckerao.h"

#include "upnpcontentserverdefs.h"

#include "upnpunsharerao.h"

_LIT( KComponentLogfile, "contentserver.txt");

#include "upnplog.h"

// FORWARD DECLARATIONS

class UPnPCommonUtils;

// CONSTANTS

const TInt KUiSelectionOffset = 2;

const TInt KDefaultGranularity( 10 );

// KContentDirCommitAmount should be in sync with KCommitEveryNum in

// upnpcontentdirectoryglobals.h which is not exported

const TInt KContentDirCommitAmount = 10;

using namespace UpnpContentServer;

// ============================ MEMBER FUNCTIONS =============================

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

// CUpnpContentSharingAo::CUpnpContentSharingAo

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUpnpContentSharingAo::CUpnpContentSharingAo(

    MUpnpSharingCallback* aEngine,

    CUpnpContentMetadataUtility* aMetadata )

    : CActive( CActive::EPriorityStandard )

    {

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

    iEngine = aEngine;

    iMetadataUtility = aMetadata;

    iContainerId = KErrNotFound;

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

    }

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

// CUpnpContentSharingAo::NewL

// Two-phased constructor.

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

//

CUpnpContentSharingAo* CUpnpContentSharingAo::NewL(

    MUpnpSharingCallback* aEngine,

    CUpnpContentMetadataUtility* aMetadata )

    {

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

    CUpnpContentSharingAo* self = new (ELeave)

        CUpnpContentSharingAo( aEngine, aMetadata );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CUpnpContentSharingAo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpContentSharingAo::ConstructL()

    {

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

    iContainerIdx = 0;

    iObjectIdx = 0;

    iVideoIndex = 0;

    iImageIndex = 0;

    iAllVideosShared = EFalse;

    iAllImagesShared = EFalse;

    CActiveScheduler::Add( this );

    iFileSharing = CUpnpFileSharing::NewL();

    ConnectMediaServer();

    iWriter = CUpnpSelectionWriter::NewL( iContainerType );

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

    }

// Destructor

CUpnpContentSharingAo::~CUpnpContentSharingAo()

    {

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

    iMediaServer.Close();

    delete iFileSharing;

    iFileSharing = NULL;

    if ( IsActive() )

        {

        __LOG1("CUpnpContentSharingAo destructor IsActive==\

true iSharingState: %d", iSharingState );

        iSharingState = ENotActive;

        TRequestStatus* stat = &iStatus;

        User::RequestComplete( stat, KErrNone );

        }

    Cancel();

    iEngine = NULL;

    iContainerIds = NULL;

    delete iTmpContainer;

    delete iSharedContainerIds;

    delete iWriter;

    DeleteListUpnpObject();

    delete iFileNameArr;   

    delete iTmpItem;

    delete iPlaylists;

    delete iCollections;

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

    }

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

// CUpnpContentSharingAo::RunL

// Called when asyncronous request is ready

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

//

void CUpnpContentSharingAo::RunL()

    {

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

    __LOG8_1( "iStatus", iStatus.Int() );

    if ( iStatus.Int() == KErrCorrupt ||

        iStatus.Int() == KErrDiskFull ||

        iStatus.Int() == KErrNoMemory )

        {

        iSharingState = ENotActive;

        }

    if ( iStopRequested == MUpnpSharingCallback::ESharingPause )

        {

        TInt err = iMediaServer.Stop(

            RUpnpMediaServerClient::EStopSilent );

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

        err = iMediaServer.StartOffline();

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

        iStopRequested = MUpnpSharingCallback::ESharingNoStop;

        }

    switch ( iSharingState )

        {

    case EUnshareContainers :

        {

        // Unshare the container structure

        UnshareContainersL();

        }

        break;

    case EShareContainers :

        {

        // Share the container structure

        ShareContainersL();

        }

        break;

    case EShareContainersResult :

        {

        // advance to next container or share items

        ShareContainersResultL();

        }

        break;

    case EShareItems :

        {

        // coming here after all containers are shared

        // then at least once per container

        HandleSharingSubstatesL();

        }

        break;

    case EShareItemsResult :

        {

        // advance to next item or end

        ShareItemsResultL();

        }

        break;

    case EShareAllItems :

        {

        //..coming to here once "All files" is selected and

        // individual albums are already shared

        HandleSharingSubstatesL();

        }

        break;

    case EShareAllItemsResult :

        {

        // advance to next item set or end

        AllItemsResultL();

        }

        break;

    case ENotActive :

        // informs handler that we are done

        {

        TInt err ( iStatus.Int() );

        if ( iStopRequested == MUpnpSharingCallback::ESharingFullStop )

            {

            // normal case

            err = KErrCancel;

            iStopRequested = EFalse;

            }

        TRAP_IGNORE( 

            iEngine->CompleteSharingOperationL( err,

                                                iContainerType ));

        }

        break;

    default :

        {

        __LOG( "RunL - default" );

        }

        break;

        }

    __LOG( "RunL - end" );

    }

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

// CUpnpContentSharingAo::DoCancel

// Cancels active object

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

//

void CUpnpContentSharingAo::DoCancel()

    {

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

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

    }

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

// CUpnpContentSharingAo::RunError

// Cancels active object

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

//

TInt CUpnpContentSharingAo::RunError( TInt aError )

    {

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

    __LOG8_1( "RunError = ", aError );

    if ( aError == KErrNoMemory ||

         aError == KErrDiskFull ||

         aError == KErrCorrupt )

        {

        iSharingState = ENotActive;

        }

    if ( iSharingState == EUnshareContainers )

        {

        if ( iShareAllSelection == EShareNone )

            {

            iSharingState = ENotActive;

            TRAP_IGNORE( iWriter->SaveSharingStateL( EShareNone ) );

            }

        else

            {

            iSharingState = EShareContainers;

            }

        }

    else

        {

        iSharingState = ENotActive;

        }

    if ( iSharingState != EEnumerateSelections )

        {

        SelfComplete( aError );

        }

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

    return KErrNone;

    }

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

// CUpnpContentSharingAo::IsActive()

// ( other items are commented in header )

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

//

TBool CUpnpContentSharingAo::IsActive() const

    {

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

    TBool ret( CActive::IsActive());

    if ( !ret )

        {

        ret = iProfilerActive;

        }

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

    return ret;

    }

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

// CUpnpContentSharingAo::HandleSharingSubstatesL

// ( other items are commented in header )

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

//

void CUpnpContentSharingAo::HandleSharingSubstatesL()

    {

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

    if ( iSharingSubState == EIdle )

        {

        if ( iSharingState == EShareItems )

            {

            ShareItemsL();

            }

        else if ( iSharingState == EShareAllItems )

            {

            ShareAllItemsL();

            }

        else

            {

            }

        }

    else if ( iSharingSubState == EProfileItemList )

        {

        ProfileItemListL();

        }

    else if ( iSharingSubState == EProfileItemListResult )

        {

        ProfileItemListResult();

        }

    else if ( iSharingSubState == EShareItemList )

        {

        TInt parentId( KErrNotFound );

        if ( iSharingState == EShareItems )

            {

            parentId = iSharedContainerIds->operator[]( iContainerIdx );

            }

        else if ( iSharingState == EShareAllItems )

            {

            parentId = iContainerId;

            }

        else

            {

            }

        ShareItemListL( parentId );

        }

    else if ( iSharingSubState == EShareItemListResult )

        {

        ShareItemListResultL();

        }

    else

        {

        }

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

    }

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

// CUpnpContentSharingAo::ShareFilesL

// Starts file sharing

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

//

void CUpnpContentSharingAo::InitializeL(

    TUpnpMediaType aContainerType,

    const RArray<TInt>& aCurrentSelection,

    CDesCArray& aPlaylistIds,

    CDesCArray& aPlaylistNames,    

    const TInt aContainerId )

    {

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

    // Initialize values

    iObjectIdx = 0;

    iContainerIdx = 0;

    iVideoIndex = 0;

    iImageIndex = 0;

    iAllVideosShared = EFalse;

    iAllImagesShared = EFalse;

    iSharingProgress = 0;

    iContainerType = aContainerType;

    delete iWriter;

    iWriter = NULL;

    iWriter = CUpnpSelectionWriter::NewL( iContainerType );

    AdjustShareAllSelection( aCurrentSelection );

    iCurrentSelections = aCurrentSelection;

    iContainerIds = &aPlaylistIds;

    iContainerNames = &aPlaylistNames;

    iContainerId = aContainerId;

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

    }

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

// CUpnpContentSharingAo::ShareFilesL

// Starts file sharing

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

//

void CUpnpContentSharingAo::ShareFiles( )

    {

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

    // Open file sharing session from mediaserver.

    // Start offline if not started.

    TInt status( RUpnpMediaServerClient::EStopped );

    iMediaServer.Status( status );

    if ( status == RUpnpMediaServerClient::EStopped )

        {

        iMediaServer.StartOffline();

        }

    iSharingState = EUnshareContainers;

    SelfComplete( KErrNone );

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

    }

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

// CUPnPSettingsEngineAO::CreateContainerL

// creates container

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

//

CUpnpContainer* CUpnpContentSharingAo::CreateContainerL(

    TUpnpMediaType aContainerType,

    const TDesC8& aTitle ) const

    {

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

    CUpnpContainer* cont= CUpnpContainer::NewL();

    CleanupStack::PushL( cont );

    cont->SetParentIdL( KRootContainerIdDesc8 );

    cont->SetTitleL( aTitle );

    switch ( aContainerType )

        {

    case EImageAndVideo :

        {

        cont->SetObjectClassL( KImageVideoContainerClass );

        }

        break;

    case EPlaylist :

        {

        cont->SetObjectClassL( KStorageFolderContainerClass );

        }

        break;

    default :

        {

        __LOG( "CreateContainerL - default");

        }

        break;

        }

    CleanupStack::Pop( cont );

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

    return cont;

    }

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

// CUpnpContentSharingAo::CloseFileSharingSession

// Closes mediaserver and file sharing session

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

//

void CUpnpContentSharingAo::CloseFileSharingSession()

    {

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

    iMediaServer.Close();

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

    }

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

// CUpnpContentSharingAo::UnshareContainersL

// Unshares objects, this should only be called from RunL

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

//

void CUpnpContentSharingAo::UnshareContainersL( )

    {

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

    // All old containers unshred, move to next state

    if ( iShareAllSelection == EShareNone )

        {

        iSharingState = ENotActive;

        iWriter->SaveSharingStateL( EShareNone );

        }

    else

        {

        iSharingState = EShareContainers;

        }