/*
 * 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:      CUpnpContentSharerAo class implementation
 *
 */
//  Include Files

#include "upnpcontentsharerao.h"
#include "upnpcontentserverdefs.h"
#include "upnpselectionwriter.h"

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

// FORWARD DECLARATIONS
// CONSTANTS

const TInt KPercent = 100;

using namespace UpnpContentServer;

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

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::CUpnpContentSharerAo
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUpnpContentSharerAo::CUpnpContentSharerAo( 
    MUpnpSharingCallback* aEngine,
    MUpnpSharingAlgorithm* aSharingAlgorithm ) 
    :
    CActive(CActive::EPriorityIdle),
    iSharingRequest( NULL )
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    iSharingEngine = aEngine;
    iSharingAlgorithm = aSharingAlgorithm;

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

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::NewL
// Two-phased constructor.
// --------------------------------------------------------------------------
//
CUpnpContentSharerAo* CUpnpContentSharerAo::NewL( 
        MUpnpSharingCallback* aEngine,
        MUpnpSharingAlgorithm* aSharingAlgorithm )
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpContentSharerAo* self = 
        new (ELeave) CUpnpContentSharerAo( aEngine, aSharingAlgorithm );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    return self;
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::ConstructL
// Symbian 2nd phase constructor can leave.
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::ConstructL()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
    
    CActiveScheduler::Add(this);

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

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::~CUpnpContentSharerAo
// Destructor
// --------------------------------------------------------------------------
//
CUpnpContentSharerAo::~CUpnpContentSharerAo()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    Cancel();
    if ( iIdle )
        {
        delete iIdle;
        iIdle = NULL;
        }

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

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::RunL
// Called when asyncronous request is ready
// --------------------------------------------------------------------------
//

void CUpnpContentSharerAo::RunL()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    __LOG8_1( "CUpnpContentSharerAo::RunL, iStatus=%d", iStatus.Int() );
    
    if ( iCancel )
        {
        // if Cancel wanted, then put iError as KErrCancel
        iError = KErrCancel;
        }    
    else if ( iStatus.Int() == KErrCorrupt || 
            iStatus.Int() == KErrDiskFull || 
            iStatus.Int() == KErrNoMemory )
        {
        // if writing sharing status failed or diskspace is full or no 
        // memory, then stop the process 
        iError = iStatus.Int();
        }
               
    if( !iError && 
        ( iShareIndex < iSharingRequest->iShareArr->Count() ||
          iUnshareIndex < iSharingRequest->iUnshareArr->Count() ) )
        {
        // handle next single file share or unshare
        TInt err = DoSingleOperation();
        
        // set progress so that Ui knows the current sharing progress.
        SetProgressL(); 
        
        //start another round
        TRequestStatus* status = &iStatus; 
        User::RequestComplete( status, err );
        SetActive();
        }
    else
        { 
        //we are done, process complete using CIdle
        if ( iIdle )
            {
            delete iIdle;
            iIdle = NULL;
            }
        iIdle = CIdle::NewL( CActive::EPriorityIdle );
        iIdle->Start( TCallBack( CompleteL, this ) );
        }
    
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::DoSingleOperation
// Handles one file sharing or unsharing
// --------------------------------------------------------------------------
//
TInt CUpnpContentSharerAo::DoSingleOperation()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
    TInt err = KErrNone;
    
    // first we go through the whole share list and then unsharing 
    if ( iShareIndex < iSharingRequest->iShareArr->Count() )
        {
        
        TFileName fileName = (*(iSharingRequest->iShareArr))[iShareIndex];
        TRAP( err, iSharingAlgorithm->ShareFileL( fileName ) );
        iShareIndex++;
        if (err != KErrNone)
            {
            // Sharing failed for some reason, not doing break here.
            // Just log and try next one.
            __LOG8_1( "Sharing item error: ", err );
            }
        }
    
    // share list done, next process the unshare list one by one 
    if ( iShareIndex == iSharingRequest->iShareArr->Count() &&
            iUnshareIndex < iSharingRequest->iUnshareArr->Count() )
        {
        TFileName fileName = 
            (*(iSharingRequest->iUnshareArr))[iUnshareIndex];
        TRAP( err, iSharingAlgorithm->UnshareFileL( fileName ) );
        iUnshareIndex++;
        if (err != KErrNone)
            {
            // Unsharing failed for some reason, not doing break here.
            // Just log and try next one.
            __LOG8_1( "Unsharing item error: ", err );
            }
        }
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    return err;
    }
// --------------------------------------------------------------------------
// CUpnpContentSharerAo::DoCancel
// Cancels active object
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::DoCancel()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    // do nothing
    
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::RunError
// Cancels active object
// --------------------------------------------------------------------------
//
TInt CUpnpContentSharerAo::RunError(TInt aError)
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
    __LOG8_1( "RunError = ", aError );
    
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    return KErrNone;
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::StartSharing
// Starts file sharing
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::StartSharing( 
    const CUpnpSharingRequest* aSharingRequest )
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    if ( IsActive() )
        {
        Cancel();
        }
    
    // initialize values for variables
    iSharingRequest = aSharingRequest;
    iCancel = EFalse;
    iError = KErrNone;
    iShareIndex = 0;
    iUnshareIndex = 0;
    iCurrentProgressPercent = 0;
    
    TInt err( KErrNone );
    if ( iSharingRequest->iShareArr && iSharingRequest->iUnshareArr )
        {
        __LOG2( "CUpnpContentSharerAo::StartSharing \
            shareArr.Count=%d, unshareArr.Count=%d", 
            iSharingRequest->iShareArr->Count(),
            iSharingRequest->iUnshareArr->Count() );

        // write the sharing status to cenrep and clf ids to file
        TRAP( err, WriteSharingStatusL() );

        // if writing sharing status failed, map all errors to KErrCorrupt
        // so that RunL handles the error
        if ( err )
            {
            err = KErrCorrupt;
            }
        }
    else
        {
        err = KErrCorrupt;
        }

    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, err );

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

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::SetProgressL
// Sets progress to engine
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::SetProgressL()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
    TInt progress(0);
    
    // Summarize total count of shared and unshared files
    TInt totalCount = iSharingRequest->iShareArr->Count() + 
                            iSharingRequest->iUnshareArr->Count();
    // Find out how many of the files are processed already 
    TInt currentCount = iShareIndex + iUnshareIndex;
    
    // No div by zero
    if( totalCount > 0 )
        {
        // calculate percent for sharing progress
        progress = currentCount * KPercent / totalCount ;
        }
    
    if ( iCurrentProgressPercent != progress )
        {
        // Set the progress information
        iCurrentProgressPercent = progress;
        iSharingEngine->SetProgressL( progress );
        }
    else
        {
        // progress percent not changed, no need to set it
        }
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::WriteSharingStatusL
// Writes the sharing status to cenrep and files
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::WriteSharingStatusL()
    {
    __LOG8_1( "%s start.", __PRETTY_FUNCTION__ );

    // Create selection writer
    CUpnpSelectionWriter* writer = 
            CUpnpSelectionWriter::NewL( iSharingRequest->iMediaType );
    CleanupStack::PushL( writer );
    
    // if sharing request is EShareMany, append clf ids to writer
    if( iSharingRequest->iSharingType == EShareMany )
        {
        if ( iSharingRequest->iClfIds )
            {
            for ( TInt i(0); i < iSharingRequest->iClfIds->MdcaCount(); i++ )
                {
                TPtrC collId = iSharingRequest->iClfIds->MdcaPoint(i);
                writer->AppendItemL( collId );
                }
            }
        else
            {
            // no clf ids, leave
            User::Leave( KErrCorrupt );
            }
        }
    
    // write sharing status to cenrep and/or file
    writer->SaveSharingStateL( iSharingRequest->iSharingType );
    
    CleanupStack::PopAndDestroy( writer );
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::SharingOngoing
// Checks whether sharing is ongoing or not.
// --------------------------------------------------------------------------
//
TBool CUpnpContentSharerAo::SharingOngoing()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );
    TBool ret(EFalse); 
    if ( iSharingRequest && 
        iSharingRequest->iShareArr &&
        iSharingRequest->iUnshareArr )
        {
        TInt totalCount = iSharingRequest->iShareArr->Count() + 
                                iSharingRequest->iUnshareArr->Count();
        TInt currentCount = iShareIndex + iUnshareIndex;
        if ( currentCount < totalCount )
            {
            // sharing still ongoing
            ret = ETrue;
            }
        }
    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    return ret;
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::StopSharing
// Stops the sharing.
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::StopSharing()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    iCancel = ETrue;

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }
    
// --------------------------------------------------------------------------
// CUpnpContentSharerAo::CompleteL
// Operation complete.
// --------------------------------------------------------------------------
//
TInt CUpnpContentSharerAo::CompleteL( TAny* aPtr )
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    CUpnpContentSharerAo* sharer = 
        static_cast<CUpnpContentSharerAo*>( aPtr );
    // callback for operation completed.
    sharer->iSharingEngine->CompleteSharingOperationL( sharer->iError, 
        sharer->iSharingRequest->iMediaType );

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    return KErrNone;
    }

// --------------------------------------------------------------------------
// CUpnpContentSharerAo::ForceSetProgress
// Forces itself to set progress in next file operation
// --------------------------------------------------------------------------
//
void CUpnpContentSharerAo::ForceSetProgress()
    {
    __LOG8_1( "%s begin.", __PRETTY_FUNCTION__ );

    // let's change the value of the current sharing progress so that 
    // the progress property is set in next file sharing operation.
    iCurrentProgressPercent--;

    __LOG8_1( "%s end.", __PRETTY_FUNCTION__ );
    }
    
// End of file