/*

* Copyright (c) 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:  Implementation of the CUpnpUploadHandler class

*

*/

// INCLUDE FILES

// System

#include <AknUtils.h>                           // CEikonEnv

#include <bautils.h>                            // BaflUtils

// upnpframework / avcontroller api

#include "upnpavcontrollerfactory.h"            // UPnPAVControllerFactory

#include "upnpavcontroller.h"                   // MUPnPAVController

#include "upnpavbrowsingsession.h"              // MUPnPAVBrowsingSession

#include "upnpfileuploadsession.h"              // MUPnPFileDownloadSession

// upnpframework / avcontroller helper api

#include "upnpfileutility.h"                    // IsFileProtectedL()

// filetransferengine internal

#include "upnpnotehandler.h"                 

#include "upnpuploadhandler.h"

_LIT( KComponentLogfile, "filetransferengine.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KZero =                      0;   

const TInt KProgressBaseValue =         100;

const TInt KUploadItemValue =           1;

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

// CUpnpUploadHandler::NewL

// NewL.

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

//

CUpnpUploadHandler* CUpnpUploadHandler::NewL(

                            MUPnPAVBrowsingSession* aBrowsingSession )

    {

    __LOG( "[CUpnpUploadHandler] CUpnpUploadHandler: NewL" );

    // Check that the browsing session is valid and has target device set.

    if( !aBrowsingSession )

        {

        User::Leave( KErrArgument );

        }

    CUpnpUploadHandler* self = NULL;

    self = new (ELeave) CUpnpUploadHandler;

    CleanupStack::PushL( self );

    self->ConstructL( aBrowsingSession );

    CleanupStack::Pop( self );

    __LOG( "[CUpnpUploadHandler] CUpnpUploadHandler: NewL end" );

    return self;

    }

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

// Constuctor

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

//

CUpnpUploadHandler::CUpnpUploadHandler()

    : CAsyncOneShot( EPriorityStandard )

    {

    __LOG( "[CUpnpUploadHandler] Constructor" );

    iUploadFirst = ETrue;

    iCopiedFileStillInArray = EFalse; 

    iDrmFilesSkipped = EFalse;

    }

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

// Destructor

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

//

CUpnpUploadHandler::~CUpnpUploadHandler()

    {

    __LOG( "[CUpnpUploadHandler] Destructor" );

    // If upload session is running, stop it

    if( iAvController &&

         iUploadSession)

        {

        iAvController->StopUploadSession( *iUploadSession );

        }

    // Delete the note handler.

    delete iNoteHandler;

    // delete the UpnpAvControllerClient

    delete iAvController;

    TInt i = 0;

    while( i < iObjectsToCopy->Count() )

        {

        if( (*iObjectsToCopy)[i] == NULL )

            {

            iObjectsToCopy->Remove( i );

            }

        else

            {

            i++;

            }    

        }

    __LOG1( "[CUpnpUploadHandler] copied %d", iTotalCount-iObjectsToCopy->Count() );

    iObjectsToCopy->Compress();

    __LOG( "[CUpnpUploadHandler] Destructor end" );

    }

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

// CUpnpUploadHandler::ConstructL

// Second phase constructor

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

//

void CUpnpUploadHandler::ConstructL(

                             MUPnPAVBrowsingSession* aBrowsingSession )

    {

    __LOG( "[CUpnpUploadHandler] ConstructL" );

    if( !aBrowsingSession )

        {

        User::Leave( KErrArgument );

        }

    // Leave if UI context is not available

    iCoeEnv = CEikonEnv::Static(); // Not owned

    if( !iCoeEnv )

        {

        User::Leave( KErrNotSupported );

        }

    // Store the browsing session

    iBrowsingSession = aBrowsingSession;

    // Create UpnpAvControllerClient

    iAvController = UPnPAVControllerFactory::NewUPnPAVControllerL();

    // Create upload session

    iUploadSession = &iAvController->StartUploadSessionL(

                                            iBrowsingSession->Device() );

    // Set this object to be the upload session observer

    iUploadSession->SetObserver( *this );

    iNoteHandler = CUpnpNoteHandler::NewL( this );

    __LOG( "[CUpnpUploadHandler] ConstructL end" );

    }

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

// CUpnpUploadHandler::UploadItemsL

// Uploads the given objects to the remote server

// (setting in the Home Media application).

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

//

void CUpnpUploadHandler::UploadItemsL( RPointerArray<TDesC16>* aObjectIds,

                                       TUpnpFileUploadMode aFileUploadMode )

    {

    __LOG( "[CUpnpUploadHandler] UploadItemsL" );

    // Check parameter

    if( aObjectIds->Count() <= 0 )

        {

        User::Leave( KErrArgument );

        }

    iUploadMode = aFileUploadMode;

    iObjectsToCopy = aObjectIds;

    iTotalCount = iObjectsToCopy->Count();

    // Initialise values

    iCopyPosition = -1;

    iCopyCompleteness = KZero;

    iCopiedFileStillInArray = EFalse;

    iStatusCode = KErrNone;

    // Start uploading the objects

    TRAP( iStatusCode, StartUploadL() );

    if( iStatusCode == KErrNone )

        {

        if( iUploadMode == EUpnpMove )

            {

            iNoteHandler->RunProgressNoteL( EUpnpMoveProgressNote );

            }

        else

            {

            iNoteHandler->RunProgressNoteL( EUpnpCopyProgressNote );

            }

        }

     /**

     * If the user cancels the copy there might be a situation 

     * where the file has just been uploaded successful but the 

     * TransferComplete is not called. 

     * In this case we need to delete that file from iObjectsToCopy.

     */

    if ( iStatusCode == KErrCancel )

        {

        if( iCopiedFileStillInArray )

            {                                           

            delete (*iObjectsToCopy)[iUploadItems];

            (*iObjectsToCopy)[iUploadItems] = NULL;  

            }

        }    

    // Leave if there was an error

    if( iStatusCode != KErrNone )

        {

        __LOG1( "[CUpnpUploadHandler] UploadItemsL leave %d", iStatusCode );

        User::Leave( iStatusCode );

        }

    __LOG( "[CUpnpUploadHandler] UploadItemsL end" );    

    }

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

// CUpnpUploadHandler::UploadPlayListL

// Uploads the given playlist to the remote server

// (setting in the Home Media application).

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

//

void CUpnpUploadHandler::UploadPlayListL(

                                     const TDesC& /*aPlaylistName*/,

                                     RPointerArray<TDesC16>* aObjectPaths,

                                     TUpnpFileUploadMode aFileUploadMode )

    {

    __LOG( "[CUpnpUploadHandler] UploadPlayListL" );

    UploadItemsL( aObjectPaths, aFileUploadMode );

    __LOG( "[CUpnpUploadHandler] UploadPlayListL end" );    

    }

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

// CUpnpUploadHandler::DialogDismissedL

// ProgressDialog call back method. Get's called when a dialog is

// dismissed.

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

//

void CUpnpUploadHandler::DialogDismissedL( )

    {

    __LOG( "[UpnpDownloadHandler] DialogDismissedL" );

    // Update the status code

    if( iStatusCode == KErrNone )

        {

        iStatusCode = KErrCancel;

        }

    iUploadSession->CancelAllTransfers();

    __LOG( "[UpnpDownloadHandler] DialogDismissedL end" );

    }

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

// CUpnpUploadHandler::MediaServerDisappeared

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

//    

void CUpnpUploadHandler::MediaServerDisappeared( 

                                    TUPnPDeviceDisconnectedReason aReason )

    {

    __LOG( "[UpnpDownloadHandler]\t MediaServerDisappeared()" );

    // Update the status code

    if( aReason == EDisconnected )

        {

        iStatusCode = KErrSessionClosed;

        }

    else if( aReason == EWLANLost )

        {

        iStatusCode = KErrDisconnected;

        }

    else

        {

        iStatusCode = KErrUnknown;

        }

    // Finish the progress note

    iNoteHandler->FinishProgressNote();

    __LOG( "[UpnpDownloadHandler]\t MediaServerDisappeared() end" );

    }

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

// CUpnpUploadHandler::TransferStarted

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

//

void CUpnpUploadHandler::TransferStarted( TInt aKey, TInt aStatus )

    {

    __LOG1( "[CUpnpUploadHandler] TransferStarted() aKey %d", aKey );

    if( !iProgressBarMaxValueSet )

        {

        iNoteHandler->SetMaxValue( iTotalCount * KProgressBaseValue );

        iProgressBarMaxValueSet = ETrue;

        }

    if( aStatus != KErrNone)

        {

        iStatusCode = aStatus;    

        }

    else if( aKey < 0 || aKey > iCopyPosition )

        {

        iStatusCode = KErrGeneral;

        }

    if( KErrNone != iStatusCode )

        {

        iNoteHandler->FinishProgressNote();    

        }

    else

        {

        TRAP_IGNORE( iUploadSession->StartTrackingProgressL( aKey ) );    

        }     

    __LOG( "[CUpnpUploadHandler] TransferStarted() end" );

    }

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

// CUpnpUploadHandler::TransferCompleted

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

//

void CUpnpUploadHandler::TransferCompleted( TInt aKey,

                                            TInt aStatus,

                                            const TDesC& /*aFilePath*/ )

    {

    __LOG( "[CUpnpUploadHandler] TransferCompleted()" );

    __LOG1( "[CUpnpUploadHandler] aKey %d", aKey );

    __LOG1( "[CUpnpUploadHandler] aStatus %d", aStatus );

    __LOG1( "[CUpnpUploadHandler] iTotalCount %d", iTotalCount );

    iStatusCode = aStatus;    

    iUploadItems++;

    __LOG1( "[CUpnpUploadHandler] iUploadItems %d", iUploadItems );

    if( KErrNone == iStatusCode && iObjectsToCopy->Count() > 0 ) 

        {

        if( iUploadMode == EUpnpMove )

            {

            __LOG( "Deleting file..." );

            TInt deleteError = BaflUtils::DeleteFile( 

                                            iCoeEnv->FsSession(),

                                            *(*iObjectsToCopy)[aKey] );

            if( deleteError != KErrNone )

            {

            __LOG( "Failed to delete file!");

            }

            }

        delete (*iObjectsToCopy)[aKey];

        (*iObjectsToCopy)[aKey] = NULL;

        iCopiedFileStillInArray = EFalse;

        // Update the download completeness percentage value

        iCopyCompleteness = KProgressBaseValue * iUploadItems;

        // Update the progress note

        iNoteHandler->SetValue( iCopyCompleteness );

        }

    if( KErrNone != iStatusCode || 

      ( aKey < 0 || aKey > iCopyPosition ) || 

        iTotalCount <= iUploadItems )

        {

        iNoteHandler->FinishProgressNote();    

        }

    else if( --iUploadIndex <=0 )

        {

        TRAPD( error, StartUploadL() );

        if( error != KErrNone )

            {

            iStatusCode = error;

            iNoteHandler->FinishProgressNote(); 

            }

        }

    __LOG( "[CUpnpUploadHandler] TransferCompleted() end" );

    }

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

// CUpnpUploadHandler::TransferProgress

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

//

void CUpnpUploadHandler::TransferProgress( TInt aKey,

                                           TInt aBytes,

                                           TInt aTotalBytes )

    {

    __LOG1( "[CUpnpUploadHandler] TransferProgress() aKey %d", aKey );

    __LOG1( "[CUpnpUploadHandler] TransferProgress() iCopyPosition %d", iCopyPosition );

    if( aKey < 0 || aKey > iCopyPosition )

        {

        iStatusCode = KErrGeneral;

        iNoteHandler->FinishProgressNote();

        }

    else

        {

        float progress = ((float)aBytes / aTotalBytes) * 100;

        if( aBytes == aTotalBytes )

            { 

            iCopiedFileStillInArray = ETrue;

            }

        iNoteHandler->SetValue( iCopyCompleteness + (TInt)progress);    

        }    

    __LOG( "[CUpnpUploadHandler] TransferProgress() -end" );

    }

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

// CUpnpUploadHandler::StartUploadL

// Starts the next upload. Leaves (KErrCompletion) if there are no more

// objects to upload.

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

//

void CUpnpUploadHandler::StartUploadL()

    {

    __LOG( "[CUpnpUploadHandler] StartUploadL()" );

    TInt error = KErrNone;

    if( iUploadFirst )

        {

        iUploadIndex = 1;

        iUploadFirst = EFalse;

        }

    else

        {

        iUploadIndex = iTotalCount - iUploadItems;

        if( iUploadIndex > KUploadItemValue )

            {

            iUploadIndex = KUploadItemValue;

            }

        else if( iUploadIndex <= 0 )

            {

            //copy is fininshed

            iStatusCode = error;

            iNoteHandler->FinishProgressNote();

            return;

            }    

        }

    for( TInt i = 0; i< iUploadIndex; i++ )

        {

        iCopyPosition++;

        TBool isDrmProtected = ETrue;

        TRAP( error, isDrmProtected = UPnPFileUtility::IsFileProtectedL( *(*iObjectsToCopy)[ iCopyPosition ] ) );

        if( error == KErrNone && isDrmProtected == EFalse)

            {

            TRAP( error, iUploadSession->StartUploadL( 

                                    *(*iObjectsToCopy)[ iCopyPosition ],

                                    iCopyPosition ) );

            }

        // If parsing or sending the download action failed, exit

        if( error != KErrNone )

            {

            iUploadSession->CancelAllTransfers();  

            iStatusCode = error;

            i = iTotalCount;

            iNoteHandler->FinishProgressNote();

            } 

        else if( isDrmProtected )

            {

            __LOG( "[CUpnpUploadHandler] StartUploadL() drm file, start timer" );

            // show note only once if there is several drm protected files

            if( !iDrmFilesSkipped )

                {

                TRAP_IGNORE( iNoteHandler->ShowSkippingDRMFilesNoteL() );

                iDrmFilesSkipped = ETrue;

                }

            // start timer to process next file   

            Call();             

            }

        }

    __LOG( "[CUpnpUploadHandler] StartUploadL() end" );

    }

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

// CUpnpUploadHandler::RunL

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

void CUpnpUploadHandler::RunL()

    {

    __LOG( "CUpnpUploadHandler::RunL" );

    iUploadItems++;

    if( --iUploadIndex <=0 )

        {

        StartUploadL();

        }

    }

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

// CUpnpUploadHandler::RunError

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

TInt CUpnpUploadHandler::RunError( TInt aError )

    {

    __LOG1( "CUpnpUploadHandler::RunError %d", aError );

    iUploadSession->CancelAllTransfers();  

    iStatusCode = aError;

    iNoteHandler->FinishProgressNote();

    return KErrNone;

    }   

// End of file