/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:      Class for handling move/copy related notes and operations.*
*/




// INCLUDE FILES
#include <CAknMemorySelectionDialogMultiDrive.h>
#include <AknWaitDialog.h>
#include <AknCommonDialogsDynMem.h>
#include <aknnotewrappers.h>
#include <StringLoader.h>
#include <vcxmyvideosdefs.h>
#include <vcxhgmyvideos.rsg>
#include "IptvDebug.h"
#include "vcxhgmyvideoscollectionclient.h"
#include "vcxhgmyvideosvideomodelhandler.h"
#include "vcxhgmyvideosmodel.h"
#include "vcxhgmyvideosvideocopier.h"
#include "CIptvDriveMonitor.h"

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

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::CVcxHgMyVideosVideoCopier()
// ---------------------------------------------------------------------------
//
CVcxHgMyVideosVideoCopier::CVcxHgMyVideosVideoCopier(
        CVcxHgMyVideosVideoListImpl& aVideoList,
        CVcxHgMyVideosVideoModelHandler& aVideoModel,
        CVcxHgMyVideosModel& aModel )
 :  iVideoList( aVideoList ),
    iVideoModel( aVideoModel ),
    iModel( aModel )
    {
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::ConstructL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::NewL()
// ---------------------------------------------------------------------------
//
CVcxHgMyVideosVideoCopier* CVcxHgMyVideosVideoCopier::NewL( 
        CVcxHgMyVideosVideoListImpl& aVideoList,
        CVcxHgMyVideosVideoModelHandler& aVideoModel,
        CVcxHgMyVideosModel& aModel )
    {
    CVcxHgMyVideosVideoCopier* self = 
        new( ELeave ) CVcxHgMyVideosVideoCopier( aVideoList, aVideoModel, aModel );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::~CVcxHgMyVideosVideoCopier()
// ---------------------------------------------------------------------------
//
CVcxHgMyVideosVideoCopier::~CVcxHgMyVideosVideoCopier()
    {
    CloseMoveCopyWaitNote();
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::ShowMenuItemsL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::ShowMenuItemsL( 
        const RArray<TInt>& aOperationTargets,
        TBool& aShowMoveAndCopySubmenu,
        TBool& aShowCopy,
        TBool& aShowMove )
    {
    CIptvDriveMonitor& driveMonitor = iModel.DriveMonitorL();
    HBufC* videoUri = NULL;
    TInt drive( 0 );

    TUint32 flags;

    for ( TInt i = 0; i < aOperationTargets.Count(); i++ )
        {
        // When we found source file that can be moved/copied, we need
        // to also check that there is target drive that we can use.
        videoUri = iVideoModel.GetVideoUri( aOperationTargets[i] ).AllocLC();
        if ( videoUri->Length() > 0 )
            {
            if ( iModel.FileServerSessionL().CharToDrive( videoUri->Des()[0], drive )
                  == KErrNone )
                {
                for ( TInt j = 0; j < driveMonitor.iAvailableDrives.Count(); j++ )
                    {
                    flags = driveMonitor.iAvailableDrives[j].iFlags;

                    if ( driveMonitor.iAvailableDrives[j].iDrive != drive &&
                            !(flags & TIptvDriveInfo::ELocked) && !(flags & TIptvDriveInfo::EMediaNotPresent) )
                        {
                        aShowMoveAndCopySubmenu = aShowCopy = aShowMove = ETrue;

                        // No need to continue, we know that menu can be shown.
                        CleanupStack::PopAndDestroy( videoUri );
                        return;
                        }
                    }
                }
            }
        CleanupStack::PopAndDestroy( videoUri );
        }
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::MoveOrCopyL()
// ---------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::MoveOrCopyL( 
        const RArray<TInt>& aOperationTargets,
        TBool aCopy )
    {
    TInt targetDrive( EDriveC );

    if ( QueryTargetDriveL( aCopy, targetDrive ) )
        {
        // Wait note is closed in destructor (CloseMoveCopyWaitNote()), 
        // in DialogDismissedL() or in VideoMoveOrCopyCompletedL().
        OpenMoveCopyWaitNoteL( aOperationTargets, aCopy );

        TRAPD( ret, iVideoModel.MoveOrCopyVideosL( aOperationTargets, targetDrive, aCopy ));
        
        if( ret != KErrNone )
            {
            CloseMoveCopyWaitNote();
            }
        
        iCopy = aCopy;
        }
    }

// ---------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::QueryTargetDriveL()
// ---------------------------------------------------------------------------
//
TBool CVcxHgMyVideosVideoCopier::QueryTargetDriveL( TBool aCopy, TInt& aTargetDrive )
    {
    TCommonDialogType dialogType;
    TBool driveSelected( EFalse );
    TDriveNumber selectedMem( EDriveC );
    TInt includedMedias( 0 );

    if ( aCopy )
        {
        dialogType = ECFDDialogTypeCopy;
        }
    else
        {
        dialogType = ECFDDialogTypeMove;
        }
    
    if ( iModel.DriveMonitorL().MassStorageDrive() != KErrNotFound )
        {
        includedMedias |= AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage;
        }
    if ( iModel.DriveMonitorL().MemoryCardDrive() != KErrNotFound )
        {
        includedMedias |= AknCommonDialogsDynMem::EMemoryTypeMMCExternalInDevice;
        }
    if ( iModel.DriveMonitorL().FixedDrive( EFalse ) == EDriveC )
        {
        includedMedias |= AknCommonDialogsDynMem::EMemoryTypePhone;
        }
    // If CIptvDriveMonitor does not publish C-drive, it means that product
    // has (at least) two other usable memories, and therefore there is no
    // need to allow user to move / copy items to (small) C-drive. 
    if ( iModel.DriveMonitorL().PhoneMemoryDrive() == KErrNotFound )
        {
        includedMedias &= ~AknCommonDialogsDynMem::EMemoryTypePhone;
        }

// Skip the dialog in emulator as ASSERT_DEBUG macro does not allow single memory dialog.
#if !defined(__WINS__) && !defined(__WINSCW__)
    CAknMemorySelectionDialogMultiDrive* dlg =
        CAknMemorySelectionDialogMultiDrive::NewL(
            dialogType,
            R_VCXHGMYVIDEOS_MEMORY_SELECTION_DIALOG,
            EFalse,
            includedMedias );
    CleanupStack::PushL( dlg );
    driveSelected = dlg->ExecuteL( selectedMem );
    CleanupStack::PopAndDestroy(); // dlg
#else
    driveSelected = ETrue;
    selectedMem = EDriveE;
#endif // !defined(__WINS__) && !defined(__WINSCW__)

    if ( driveSelected )
        {
        aTargetDrive = static_cast<TInt>( selectedMem );
        return ETrue;
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::OpenMoveCopyWaitNoteL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::OpenMoveCopyWaitNoteL( 
    const RArray<TInt>& aOperationTargets,
    TBool aCopy )
    {
    CloseMoveCopyWaitNote();

    HBufC* note = NULL;

    if ( aOperationTargets.Count() == 1 )
        {
        HBufC* name = iVideoModel.GetVideoName( aOperationTargets[0] ).AllocLC();
        if ( aCopy )
            {
            note = StringLoader::LoadL( R_VCXHGMYVIDEOS_COPYING_ONE, *name );
            }
        else
            {
            note = StringLoader::LoadL( R_VCXHGMYVIDEOS_MOVING_ONE, *name );
            }
        CleanupStack::PopAndDestroy( name );
        CleanupStack::PushL( note );
        }
    else
        {
        if ( aCopy )
            {
            note = StringLoader::LoadLC( R_VCXHGMYVIDEOS_COPYING_MANY );
            }
        else
            {
            note = StringLoader::LoadLC( R_VCXHGMYVIDEOS_MOVING_MANY );
            }
        }

    iMoveCopyWaitDialog = new (ELeave) 
            CAknWaitDialog( ( REINTERPRET_CAST( CEikDialog**, &iMoveCopyWaitDialog ) ), ETrue );
    iMoveCopyWaitDialog->SetCallback( this );
    iMoveCopyWaitDialog->SetTextL( *note );
    
    if ( aCopy )
        {
        iMoveCopyWaitDialog->ExecuteLD( R_VCXHGMYVIDEOS_COPY_WAIT_NOTE );
        }
    else
        {
        iMoveCopyWaitDialog->ExecuteLD( R_VCXHGMYVIDEOS_MOVE_WAIT_NOTE );
        }

    CleanupStack::PopAndDestroy( note );
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::CloseMoveCopyWaitNote()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::CloseMoveCopyWaitNote()
    {
    if ( iMoveCopyWaitDialog )
        {
        TRAPD( error, iMoveCopyWaitDialog->ProcessFinishedL() );
        if ( error != KErrNone )
            {
            delete iMoveCopyWaitDialog;
            }
        iMoveCopyWaitDialog = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::DialogDismissedL()
// Callback about (move/copy) wait note dismissal.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::DialogDismissedL( TInt aButtonId )
    {
    if ( aButtonId == EAknSoftkeyCancel )
        {
        iModel.CollectionClient().CancelMoveOrCopyVideosL();
        }
    iMoveCopyWaitDialog = NULL;
    }

// -----------------------------------------------------------------------------
// CVcxHgMyVideosVideoCopier::VideoMoveOrCopyCompletedL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosVideoCopier::VideoMoveOrCopyCompletedL( TInt aFailedCount,
                                                           const TDesC& aFailedName )
    {
    CloseMoveCopyWaitNote();

    if ( aFailedCount > 0 )
        {
        HBufC* text = NULL;

        if ( aFailedCount == 1 )
            {
            if ( iCopy )
                {
                text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_ITEM_CANNOT_BE_COPIED,
                                             aFailedName );
                }
            else
                {
                text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_ITEM_CANNOT_BE_MOVED,
                                             aFailedName );                
                }
            }
        else
            {
            if ( iCopy )
                {
                text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_SOME_ITEMS_CANT_COPY, 
                                             aFailedCount );
                }
            else
                {
                text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_SOME_ITEMS_CANT_MOVE, 
                                             aFailedCount );                
                }            
            }

        CAknErrorNote* note = new ( ELeave ) CAknErrorNote( ETrue );
        note->ExecuteLD( *text );
        CleanupStack::PopAndDestroy( text );  
        }    
    }