/*

* 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:  Implementation of the CUpnpFileTransferHandler class

*

*/

// INCLUDE FILES

// System

#include <eikenv.h>                             // CEikonEnv

#include <eikprogi.h>                           // CEikProgressInfo

#include <bautils.h>                            // BaflUtils

#include <data_caging_path_literals.hrh>        // KDC_RESOURCE_FILES_DIR

#include <upnpitem.h>                           // CUpnpItem

#include <upnpcontainer.h>                      // CUpnpContainer

#include <upnpstring.h>                         // UpnpString

// upnpavcontroller api

#include "upnpavbrowsingsession.h"              // MUPnPAVSessionBase

#include "upnpavcontrollerfactory.h"            // UPnPAVControllerFactory

#include "upnpavcontroller.h"                   // MUPnPAVController

#include "upnpfiledownloadsession.h"            // MUPnPFileDownloadSession

// upnpavcontroller / xml parser api

#include "upnpxmlparser.h"

// upnpframework / internal api's

#include "upnpgallerynotifier.h"                // UpnpGalleryNotifer

// filetransferengine internal

#include <upnpfiletransferengineresources.rsg>  // Dialog resources

#include "upnpfiletransferhandler.h"            // CUpnpFileTransferHandler

// CONSTANTS

_LIT( KResFileName,                 "upnpfiletransferengineresources.rsc");

_LIT8( KBrowseSortCriteria,         "" );

_LIT8( KBrowseFilter,               "*" );

const TInt KBrowseRequestCount =        1;

const TInt KProgressInfoInitialValue =  1;

const TInt KProgressInfoFinalValue =    50000;

const TInt KProgressNoteStepper =       2;

const TInt KCopyPositionInitialValue =  0;

_LIT( KComponentLogfile, "filetransferengine.txt");

#include "upnplog.h"

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

// CUpnpFileTransferHandler::NewL

// NewL.

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

//

CUpnpFileTransferHandler* CUpnpFileTransferHandler::NewL(

        MUPnPAVBrowsingSession* aBrowsingSession )

    {

    __LOG( "CUpnpFileTransferHandler::NewL"  );

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

    if( !aBrowsingSession )

        {

        User::Leave( KErrArgument );

        }

    CUpnpFileTransferHandler* self = NULL;

    self = new (ELeave) CUpnpFileTransferHandler;

    CleanupStack::PushL( self );

    self->ConstructL( aBrowsingSession );

    CleanupStack::Pop( self );

    __LOG( "CUpnpFileTransferHandler::NewL -end"  );

    return self;

    }

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

// Constuctor

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

//

CUpnpFileTransferHandler::CUpnpFileTransferHandler()

    {

    __LOG( "CUpnpFileTransferHandler::CUpnpFileTransferHandler" );

    iNumCopiedItemFromContainer = 0;

    __LOG( "CUpnpFileTransferHandler::CUpnpFileTransferHandler -end" );

    }

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

// Destructor

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

//

CUpnpFileTransferHandler::~CUpnpFileTransferHandler()

    {

    __LOG( "CUpnpFileTransferHandler::~CUpnpFileTransferHandler" );

    // Restore the browse session observer

    if( iBrowsingSession &&

        iBrowsingSessionObserverBackup )

        {

        iBrowsingSession->RemoveObserver();

        iBrowsingSession->SetObserver( *iBrowsingSessionObserverBackup );

        }

    // Delete the playlist handler.

    delete iPlaylistHandler;

    // Delete copy item (used in container and playlist copy) is it exists

    delete iCopyItem;

    // Deletes download session and avcontroller instances.

    if( iDownloadSession && iAvController )

        {

        iAvController->StopDownloadSession( *iDownloadSession );

        }

    delete iAvController;

    // Un-load resource file

    if ( iResFileOffset )

        {

        iCoeEnv->DeleteResourceFile( iResFileOffset );

        iResFileOffset = 0;

        }

    __LOG( "CUpnpFileTransferHandler::~CUpnpFileTransferHandler -end" );

    }

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

// CUpnpFileTransferHandler::ConstructL

// Second phase constructor

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

//

void CUpnpFileTransferHandler::ConstructL(

        MUPnPAVBrowsingSession* aBrowsingSession )

    {

    __LOG( "CUpnpFileTransferHandler::ConstructL" );

    if( aBrowsingSession )

        {

        iBrowsingSession = aBrowsingSession;

        }

    else

        {

        User::Leave( KErrArgument );

        }

    // Leave if UI context is not available

    iCoeEnv = CEikonEnv::Static();

    if( !iCoeEnv )

        {

        User::Leave( KErrNotReady );

        }

    // Get the file server session handle

    RFs& fs = iCoeEnv->FsSession();

    // Parse the resource file path

    TParse parse;

    parse.Set( KResFileName, &KDC_RESOURCE_FILES_DIR, NULL );

    TFileName rscFileName;

    rscFileName.Append( parse.FullName() );

    TFileName dllName;

    Dll::FileName( dllName );

    TBuf<2> drive = dllName.Left( 2 ); // Drive letter followed by ':' 

    rscFileName.Insert( 0, drive );

    // Get the exact filename of the resource file

    BaflUtils::NearestLanguageFile( fs, rscFileName );

    // Check if the resource file exists or not

    if ( !BaflUtils::FileExists( fs, rscFileName ) )

        {

        __LOG( "Resource file does not exist!" );

        User::Leave( KErrNotFound );

        }

    // Read the resource file offset

    iResFileOffset = iCoeEnv->AddResourceFileL( rscFileName );

    // Backup the browse session observer and set this object as an observer.

    iBrowsingSessionObserverBackup = iBrowsingSession->Observer();

    iAvController = UPnPAVControllerFactory::NewUPnPAVControllerL();

    // Create download session

    iDownloadSession = &iAvController->StartDownloadSessionL(

                                            iBrowsingSession->Device() );

    // Set this object to be the download session observer

    iDownloadSession->SetObserver( *this );

    iFileTransferMode = EUpnpIdleTransferMode;

    // Instantiate the playlist handler

    iPlaylistHandler = CUpnpPlaylistHandler::NewL();

    __LOG( "CUpnpFileTransferHandler::ConstructL -end" );

    }

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

// CUpnpFileTransferHandler::TransferRemoteItemsToHandsetL

// Copies items from a remote Upnp Media Server to the handset.

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

//

void CUpnpFileTransferHandler::TransferRemoteItemsToHandsetL(

        TUpnpFileTransferMode aTransferMode,

        RPointerArray<CUpnpItem>& aItems )

    {

    __LOG( "CUpnpFileTransferHandler::TransferRemoteItemsToHandsetL" );

    if( aItems.Count() <= 0 ||

        aTransferMode != EUpnpCopyRemoteItemsToDefaultLocation )

        {

        User::Leave( KErrArgument ); 

        }

    // Initialise member variables

    iFileTransferMode = aTransferMode;

    iCopyItems = &aItems;

    iCopyPosition = KCopyPositionInitialValue;

    iStatusCode = KErrNone;

    // Copy the first file

    TRAP( iStatusCode, iDownloadSession->StartDownloadL( 

            (*(*iCopyItems)[iCopyPosition]),

            iCopyPosition ) );

    // If first copy action was sent succesfully, draw the progress note,

    // otherwise leave with the error code

    if( iStatusCode == KErrNone )

        {

        RunCopyNoteL( iCopyItems->Count() );

        }

    // Notify Media Gallery of the filesystem changes (files added)

    TRAP_IGNORE( UpnpGalleryNotifier::NotifyMediaGalleryL() );

    // Clean up

    iFileTransferMode = EUpnpIdleTransferMode;

    // Leave if there was an error

    if( iStatusCode != KErrNone )

        {

        User::Leave( iStatusCode );

        }

    __LOG( "CUpnpFileTransferHandler::TransferRemoteItemsToHandsetL -end" );

    }

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

// CUpnpFileTransferHandler::TransferRemoteContainerToHandsetL

// Copies a container from a remote Upnp Media Server to the handset.

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

//

void CUpnpFileTransferHandler::TransferRemoteContainerToHandsetL(

        TUpnpFileTransferMode aTransferMode,

        CUpnpContainer* aSourceContainer )

    {

    __LOG( "CUpnpFileTransferHandler::TransferRemoteContainerToHandsetL" );

    iStatusCode = KErrNone;

    if( !aSourceContainer ||

        aSourceContainer->Title() == KNullDesC8 ||

        ( aTransferMode != EUpnpCopyRemoteContainerToDefaultLocation &&

          aTransferMode != EUpnpCopyRemotePlaylistToDefaultLocation ) )

        {

        User::Leave( KErrArgument );

        }

    // Reset the playlist handler

    iPlaylistHandler->Reset();

    // Convert the container title to playlist name

    HBufC* titleUnicode = NULL;

    titleUnicode = UpnpString::ToUnicodeL( aSourceContainer->Title() );

    CleanupStack::PushL( titleUnicode );

    iPlaylistHandler->SetPlaylistNameL( *titleUnicode );

    CleanupStack::PopAndDestroy( titleUnicode );

    titleUnicode = NULL;

    // Initialise copy related member variables

    iCopyFromContainer = aSourceContainer;

    iFileTransferMode = aTransferMode;

    iContainerCopyFirstBrowse = ETrue;

    iContainerCopyBrowseIndex = 0;

    iBrowsingSession->SetObserver( *this );

    // Start the copy process

    TRAP( iStatusCode,

          iBrowsingSession->BrowseL(

                              iCopyFromContainer->Id(),

                              KBrowseFilter(),

                              MUPnPAVBrowsingSession::EDirectChildren,

                              iContainerCopyBrowseIndex,

                              KBrowseRequestCount,

                              KBrowseSortCriteria() ) );

    if( iStatusCode == KErrNone )

        {

        // Start the progress Dialog, but do not set current and 

        // final values for the progress bar. This info will be set

        // when the first browse result will be reseived.

        RunCopyNoteL();

        // If no files were copied, change the copy status code

        if( iPlaylistHandler->AudioItemCount() <= 0 &&

            iPlaylistHandler->ImageItemCount() <= 0 &&

            iPlaylistHandler->VideoItemCount() <= 0 &&

            iStatusCode == KErrNone )

            {

            iStatusCode = KErrNotFound;

            }

        // If files were copied, create playlists, albums and notify

        // Media Gallery

        else

            {

            // If audio files were copied, and the operation was to

            // copy a playlist, then create a MPX playlist

            if( iPlaylistHandler->AudioItemCount() > 0 &&

                ( aTransferMode ==

                        EUpnpCopyRemotePlaylistToDefaultLocation ) )

                {

                TRAP_IGNORE( iPlaylistHandler->CreateMusicPlaylistL() );

                }

            // If image files were copied, create an image album

            if( iPlaylistHandler->ImageItemCount() > 0 &&

                ( aTransferMode ==

                        EUpnpCopyRemoteContainerToDefaultLocation ) )

                {

                TRAP_IGNORE( iPlaylistHandler->CreateImageAlbumL() );

                }

            // If video files were copied, create a video album

            if( iPlaylistHandler->VideoItemCount() > 0 &&

                ( aTransferMode ==

                        EUpnpCopyRemoteContainerToDefaultLocation ) )

                {

                TRAP_IGNORE( iPlaylistHandler->CreateVideoAlbumL() );

                }

            }

        // Notify Media Gallery of filesystem changes, if files were

        // added.

        if( iPlaylistHandler->ImageItemCount() > 0 ||

            iPlaylistHandler->VideoItemCount() > 0 || 

            iPlaylistHandler->AudioItemCount() > 0 )

            {

            __LOG( "Notifying the Media Gallery of new \

image/video/music files." );

            TRAP_IGNORE( UpnpGalleryNotifier::NotifyMediaGalleryL() );

            }

        __LOG( "TransferRemoteContainerToHandsetL Reset");

        // Reset the playlist handler

        iPlaylistHandler->Reset();

        }

    // Set file transfer mode to idle

    iFileTransferMode = EUpnpIdleTransferMode;

    // If the copy failed, leave with the error code

    if( iStatusCode != KErrNone )

        {

        User::Leave( iStatusCode );

        }

    __LOG( "CUpnpFileTransferHandler::TransferRemoteContainerToHandsetL -end" );

    }

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

// CUpnpFileTransferHandler::CopyCompleteContainersL

// Handles the copy complete callback when copying containers.

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

//

void CUpnpFileTransferHandler::CopyCompleteContainersL(

        TInt aError,

        const TDesC& aFilepath )

    {

    __LOG( "CUpnpFileTransferHandler::CopyCompleteContainersL" );

    // Update the progress note

    iCurrentProgressValue++;

    if( iProgressInfo )

        {

        iProgressInfo->SetAndDraw( iCurrentProgressValue );

        }

    if( aError == KErrNone )

        {

        iNumCopiedItemFromContainer++;

        // Resolve the type of the media file

        TUPnPItemType itemType = ResolveFileType( aFilepath );

        // Add the file to playlist handler's lists

        if( itemType == ETypeAudio &&

            iCopyItem )

            {

            TRAP_IGNORE(

                iPlaylistHandler->NotifyNewAudioFileL(

                    aFilepath, *iCopyItem );

                iPlaylistHandler->AddAudioItemL( aFilepath ) );

            }

        else if( itemType == ETypeVideo )

            {

            TRAP_IGNORE( iPlaylistHandler->AddVideoItemL( aFilepath) );

            }

        else if( itemType == ETypeImage )

            {

            TRAP_IGNORE( iPlaylistHandler->AddImageItemL( aFilepath) );

            }

        else

            {

            // Nothing

            }

        }

    // Clean up the copy item

    delete iCopyItem;

    iCopyItem = NULL;

    // If the copy of the previous file failed with any error code, quit the

    // whole copy operation

    if( aError != KErrNone )

        {

        iStatusCode = aError;

        FinishNotes();

        return;

        }

    // If there are more objects (possibly items), browse for the next one,

    // otherwise finish the progress note.

    if( iContainerCopyBrowseIndex < iContainerCopyBrowseTotalCount )

        {

        iBrowsingSession->SetObserver( *this );

        TRAPD( browseError,

               iBrowsingSession->BrowseL(

                                  iCopyFromContainer->Id(),

                                  KBrowseFilter(),

                                  MUPnPAVBrowsingSession::EDirectChildren,

                                  iContainerCopyBrowseIndex,

                                  KBrowseRequestCount,

                                  KBrowseSortCriteria() ) );

        // If the browse could not be sent, finish the operation

        if( browseError != KErrNone && KErrServerBusy != browseError )

            {

            // Update the status code

            if( iStatusCode == KErrNone )

                {

                iStatusCode = browseError;

                }

            FinishNotes();

            }

        }

    else

        {

        FinishNotes();

        }

    __LOG( "CUpnpFileTransferHandler::CopyCompleteContainersL -end" );

    }

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

// CUpnpFileTransferHandler::CopyCompleteFilesL

// Handles the copy complete callback when copying files

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

//

void CUpnpFileTransferHandler::CopyCompleteFilesL( 

        TInt aError,

        const TDesC& aFilepath )

    {

    __LOG1( "CUpnpFileTransferHandler::CopyCompleteFilesL %d", aError );

    if( aError == KErrNone )

        {

        iCurrentProgressValue = iCurrentProgressValue + iProgressIncrement;

        if( iProgressInfo )

            {

            iProgressInfo->SetAndDraw( iCurrentProgressValue );

            }

        // If a new file was copied to the handset, inform MPX

        TInt returnValue = KErrNone;

        if( iFileTransferMode == EUpnpCopyRemoteItemsToDefaultLocation )

            {

            if( (*iCopyItems)[iCopyPosition] )

                {

                // Resolve the type of the media file

                TUPnPItemType itemType = ResolveFileType( aFilepath );

                // Nofity MPX of a new file

                if( itemType == ETypeAudio )

                    {

                    TRAP_IGNORE( iPlaylistHandler->NotifyNewAudioFileL(

                        aFilepath, *(*iCopyItems)[iCopyPosition] ) );

                    }

                }

            // Delete the filename and remove from the array

            delete (*iCopyItems)[iCopyPosition];

            (*iCopyItems)[iCopyPosition] = NULL;

            iCopyItems->Remove( iCopyPosition );

            iCopyItems->Compress();

            if( iCopyPosition > iCopyItems->Count() ||

                iCopyPosition == iCopyItems->Count() )

                {

                __LOG( "All files copied. Exiting..." );

                // Finish the progress Dialog

                iStatusCode = aError;

                FinishNotes();

                }

            // If there are still more files to copy, increment the position

            // counter, and do the next copy