/*

* 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:      This module handlers the cleaning and creating of the

 *                filesystem to mediaserver

 *

*/

#include <e32debug.h>

#include "upnpcommonutils.h"

#include "upnpcontentserverdefs.h"

#include "upnpcontainercheckerao.h"

#include "upnpunsharerao.h"

_LIT( KComponentLogfile, "contentserver.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KDefaultBrowseReqCount( 100 );

const TInt KDefaultBrowseStartingInd( 0 );

using namespace UpnpContentServer;

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

// CUpnpContainerCheckerAo::CUpnpContainerCheckerAo()

// C++ constructor.

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

//

CUpnpContainerCheckerAo::CUpnpContainerCheckerAo(

    MUpnpSharingCallback* aCallback ) :

    CActive( CActive::EPriorityIdle ),

    iCallback( aCallback )

    {

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

    iCurrentOperation = ENotActive;

    iState = EIdle;

    iTotalMatches = KErrNotFound;

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

    }

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

// CUpnpContainerCheckerAo::~CUpnpContainerCheckerAo()

// C++ destructor.

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

//

CUpnpContainerCheckerAo::~CUpnpContainerCheckerAo()

    {

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

    delete iFileSharing;

    iFileSharing = NULL;

    iMediaServer.Close();

    if ( IsActive() )

        {

        __LOG1("CUpnpContainerCheckerAo destructor IsActive iCurrentOp=%d",

              iCurrentOperation );

        iCurrentOperation = ENotActive;

        TRequestStatus* stat = &iStatus;

        User::RequestComplete( stat, KErrNone );

        }

    Cancel();

    Cleanup();

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

    }

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

// CUpnpContainerCheckerAo::ValidateContainerStructureL

// ( other items are commented in header )

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

//

TInt CUpnpContainerCheckerAo::ValidateContainerStructureL( 

    RArray<TInt>* aIds )

    {

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

    CActiveScheduler::Add( this );

    TInt err( KErrNotFound );

    iClientIds = aIds;

    // First initialize resources

    iOperationMode = EValidateContainers;

    iCurrentOperation = EInitialize;

    SelfComplete( KErrNone );

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

    return err;

    }

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

// CUpnpContainerCheckerAo::GetDefaultContainerIdsL

// ( other items are commented in header )

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

//

TInt CUpnpContainerCheckerAo::CheckDefaultContainersL(

    RArray<TInt>* aIds )

    {

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

    iOperationMode = ECheckDefaultContainers;

    TInt err( KErrNone );

    iClientIds = aIds;

    CActiveScheduler::Add( this );

    iCurrentOperation = EInitialize;

    SelfComplete( KErrNone );

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

    return err;

    }

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

// CUpnpContainerCheckerAo::RequestStop

// ( other items are commented in header )

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

//

void CUpnpContainerCheckerAo::RequestStop(

    MUpnpSharingCallback::TSharingStopType aStopType )

    {

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

    iStopRequested = aStopType;

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

    }

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

// CUpnpContainerCheckerAo::InitializeL

// ( other items are commented in header )

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

//

TInt CUpnpContainerCheckerAo::InitializeL()

    {

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

    // First initialize resources

    iFileSharing = CUpnpFileSharing::NewL();

    TInt error( iMediaServer.Connect() );

    if ( error )

        {

        __LOG8_1( "iMediaServer.Connect err: %d",error );

        }

    User::LeaveIfError( error );

    if ( !error )

        {

        // start offline if not started

        TInt status( RUpnpMediaServerClient::EStopped );

        error = iMediaServer.Status( status );

        if ( !error && status == RUpnpMediaServerClient::EStopped )

            {

            error = iMediaServer.StartOffline();

            }

        }

    SelfComplete( error );

    iCurrentOperation = EQueryDefaultContainers;

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

    return error;

    }

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

// CUpnpContainerCheckerAo::QueryDefaultContainerIdsL

// ( other items are commented in header )

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

//

void CUpnpContainerCheckerAo::QueryDefaultContainerIdsL()

    {

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

    iState = EResolveDefaultContainerIds;

    CUpnpBrowseCriteria* browseCriteria = CreateBrowseCriteriaLC();

    delete iContainerList;

    iContainerList = NULL;

    iContainerList = CUpnpContainerList::NewL();

    // Get shared containers to iContainerList

    iFileSharing->GetSharedContainerListL( KRootContainerId,

                                           *browseCriteria,

                                           *iContainerList,

                                           iMatchCount,

                                           iStatus );

    iCurrentOperation = EQueryDefaultContainersResult;

    CleanupStack::PopAndDestroy( browseCriteria );

    SetActive();

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

    }

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

// CUpnpContainerCheckerAo::QueryDefaultContainerIdsResultL

// ( other items are commented in header )

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

//

void CUpnpContainerCheckerAo::QueryDefaultContainerIdsResultL()

    {

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

    CUpnpContainer* tmpContainer( NULL );

    if ( !iContainerList )

        {

        User::Leave( KErrGeneral );

        }

    switch ( iContainerPosition )

        {

    case CUpnpContainerCheckerAo::EImageAndVideo :

        {

        tmpContainer =

            UPnPCommonUtils::FindContainerByTitle( *iContainerList,

                                                   KImageContainerName );

        if ( tmpContainer )

            {

            iImageVideoContainerId = UPnPCommonUtils::DesC8ToInt(

                tmpContainer->Id() );

            iContainerList->RemoveAndDestroy( tmpContainer->Id() );

            tmpContainer = NULL;

            iContainerPosition++;

            iCurrentOperation = EQueryDefaultContainersResult;

            SelfComplete( KErrNone );

            }

        else

            {

            iCurrentOperation = EShareContainer;

            ShareContainerL( iContainerPosition );

            }

        }

    break;

    case CUpnpContainerCheckerAo::EMusic :

        {

        tmpContainer =

            UPnPCommonUtils::FindContainerByTitle( *iContainerList,

                                                   KMusicContainerName );

        if ( tmpContainer )

            {

            iMusicContainerId = UPnPCommonUtils::DesC8ToInt(

                tmpContainer->Id() );

            iContainerList->RemoveAndDestroy( tmpContainer->Id() );

            tmpContainer = NULL;

            iContainerPosition++;

            iCurrentOperation = EQueryDefaultContainersResult;

            SelfComplete( KErrNone );

            }

        else

            {

            iCurrentOperation = EShareContainer;

            ShareContainerL( iContainerPosition );

            }

        }

    break;

    case CUpnpContainerCheckerAo::EUploaded :

        {

        tmpContainer =

            UPnPCommonUtils::FindContainerByTitle( *iContainerList,

                                                   KUploadedContainerName );

        if ( tmpContainer )

            {

            iUploadContainerId = UPnPCommonUtils::DesC8ToInt(

                tmpContainer->Id() );

            iContainerList->RemoveAndDestroy( tmpContainer->Id() );

            tmpContainer = NULL;

            iContainerPosition++;

            iCurrentOperation = EQueryDefaultContainersResult;

            SelfComplete( KErrNone );

            }

        else

            {

            iCurrentOperation = EShareContainer;

            ShareContainerL( iContainerPosition );

            }

        }

    break;

    default :

        {

        // Store IDs of possible unwanted containers

        if ( iOperationMode != ECheckDefaultContainers )

            {

            for ( TInt i(0); i< iContainerList->ObjectCount(); i++ )

                {

                tmpContainer = static_cast< CUpnpContainer* >(

                    iContainerList->operator[]( i ));

                iSharedContainerIds.AppendL(

                    UPnPCommonUtils::DesC8ToInt( tmpContainer->Id() ) );

                }

            iState = EUnshareExtraContainers;

            iCurrentOperation = EUnshareContainer;

            }

        else

            {

            iCurrentOperation = ENotActive;

            }

        // Just add the Ids to client

        if ( iClientIds )

            {

            iClientIds->Reset();

            iClientIds->Append( iImageVideoContainerId );

            iClientIds->Append( iMusicContainerId );

            iClientIds->Append( iUploadContainerId );

            iClientIds->Compress();

            }

        delete iContainerList;

        iContainerList = NULL;

        SelfComplete( KErrNone );

        }

        break;

        }

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

    }

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

// CUpnpContainerCheckerAo::RunL

// ( other items are commented in header )

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

//

void CUpnpContainerCheckerAo::RunL()

    {

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

    if ( iStatus.Int() )

        {

        __LOG1( "Error: %d", iStatus.Int() );

        }

    if ( iStatus.Int() == KErrCorrupt )

        {

        if ( iRecoverError == ENoError )

            {

            iRecoverError = EDropAllContent;

            }

        else

            {

            iCurrentOperation = ENotActive;

            iRecoverError = ENoError;

            }

        }

    else if ( iStatus.Int() == KErrNoMemory ||

              iStatus.Int() == KErrDiskFull ||

              iStatus.Int() == KErrServerTerminated )

             {

             iCurrentOperation = ENotActive;

             SelfComplete( iStatus.Int() );

             }

    if ( iRecoverError )

        {

        switch ( iRecoverError )

            {

        case EDropAllContent :

            {

            iFileSharing->DropAllContentL( iStatus );

            iRecoverError = EDropAllContentResult;

            SetActive();

            }

            break; 

        case EDropAllContentResult :

            {

            if ( iStatus.Int() == KErrCorrupt )

                {

                iCurrentOperation = ENotActive;

                SelfComplete( iStatus.Int() );

                }

            else

                {

                iRecoverError = ENoError;

                SelfComplete( KErrNone );

                }

            }

            break;    

        default:

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

            break;

            }

        }

    else

        {

        if ( iStopRequested == MUpnpSharingCallback::ESharingPause )

            {

            delete iFileSharing;

            iFileSharing = NULL;

            iFileSharing = CUpnpFileSharing::NewL();

            TInt e = iMediaServer.Stop( 

                         RUpnpMediaServerClient::EStopSilent );

            if ( e )

                {

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

                }

            e = iMediaServer.StartOffline();

            if ( e )

                {

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

                }

            iStopRequested = MUpnpSharingCallback::ESharingNoStop;

            }

        switch ( iCurrentOperation )

            {

        case EInitialize :

            {

            InitializeL();

            }

            break;

        case EQueryDefaultContainers :

            {

            QueryDefaultContainerIdsL();

            }

            break;

        case EQueryDefaultContainersResult :

            {

            QueryDefaultContainerIdsResultL();

            }

            break;

        case EUnshareItemList :

            {

            UnshareItemListL();

            }

            break;

        case EQueryItemFromMediaServer :

            {

            QueryContainerItemsL();

            }

            break;

        case EQueryItemFromMediaServerResult :

            {

            QueryItemFromCdsResultL();

            }

            break;

        case EShareContainer :

            {

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

            }

            break;

        case EShareContainerResult :

            {

            ShareContainerResult();

            }

            break;

        case ENotActive :

            {

            Cleanup();

            if ( iCallback )

                {

                iCallback->CompleteSharingOperationL( iStatus.Int(), 0 );

                }

            }

            // all operations requested done

            break;

        case EUnshareContainer :

            {

            UnshareContainerL();

            }

            break;

        case EUnshareContainerResult :

            {

            UnshareContainerResultL();

            }

            break;

        default :

            {

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

            break;

            }

            }

        }

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

    }

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

// CUpnpContainerCheckerAo::DoCancel

// Cancels active object

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

//

void CUpnpContainerCheckerAo::DoCancel()

    {

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

    // NOTE: The cancelling of mediaserver request must be made in destructor

    // because there is no cancel in CUpnpFileSharing

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

    }

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

// CUpnpContainerCheckerAo::RunError

// ( other items are commented in header )

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

//

TInt CUpnpContainerCheckerAo::RunError( TInt aError )

    {

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

    if ( aError )

        {

        __LOG8_1( "CUpnpContainerCheckerAo::RunError", aError );

        }

    TInt ret( KErrNone );

    if ( aError == KErrNoMemory ||

         aError == KErrDiskFull ||

         aError == KErrCorrupt )

        {

        iCurrentOperation = ENotActive;

        SelfComplete( aError );

        }

    else 

        {

        }

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

    return ret;

    }