/*

* 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:      Implementation of UI functionality for video list.*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <centralrepository.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <bautils.h>  

#include <gulicon.h>

#include <fbs.h>

#include <sendui.h>

#include <SendUiConsts.h>

#include <CMessageData.h>

#include <MessagingDomainCRKeys.h>

#include <ganes/HgScroller.h>

#include <ganes/HgDoubleGraphicList.h>

#include <AknWaitDialog.h> 

#include <vcxhgmyvideos.rsg>

#include <vcxhgmyvideosicons.mbg>

#include <vcxmyvideosdefs.h>

#include <myvideosindicator.h>

#include "IptvDebug.h"

#include <mpxplaybackutility.h>

#include <mpxviewutility.h>

#include <mpxcommandgeneraldefs.h>

#include "vcxhgmyvideosvideolistimpl.h"

#include "vcxhgmyvideosvideomodelhandler.h"

#include "vcxhgmyvideosmodel.h"

#include "vcxhgmyvideosmainview.h"

#include "vcxhgmyvideoscollectionclient.h"

#include "vcxhgmyvideos.hrh"

#include "vcxhgmyvideosvideocopier.h"

#include "vcxhgmyvideospanics.h"

#include "vcxhgmyvideosupnpinterface.h"

#ifdef RD_VIDEO_AS_RINGING_TONE

#include "vcxhgmyvideosaiwmenuhandler.h"

#endif

_LIT( KVcxHgMyVideosMifFile, "\\resource\\apps\\vcxhgmyvideosicons.mif" );

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

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

// CVcxHgMyVideosVideoListImpl::NewL()

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

//

CVcxHgMyVideosVideoListImpl* CVcxHgMyVideosVideoListImpl::NewL(

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )

    {

    CVcxHgMyVideosVideoListImpl* self = 

        CVcxHgMyVideosVideoListImpl::NewLC( aModel, aView, aScroller );

    CleanupStack::Pop( self );

    return self;

    }

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

// CVcxHgMyVideosVideoListImpl::NewLC()

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

//

CVcxHgMyVideosVideoListImpl* CVcxHgMyVideosVideoListImpl::NewLC(

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )

    {

    CVcxHgMyVideosVideoListImpl* self = 

        new (ELeave) CVcxHgMyVideosVideoListImpl( aModel, aView, aScroller );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CVcxHgMyVideosVideoListImpl::CVcxHgMyVideosVideoListImpl()

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

//

CVcxHgMyVideosVideoListImpl::CVcxHgMyVideosVideoListImpl( 

        CVcxHgMyVideosModel& aModel,

        CVcxHgMyVideosMainView& aView,

        CHgScroller& aScroller )

  : CVcxHgMyVideosListBase( aModel, aView, aScroller )

#ifdef RD_VIDEO_AS_RINGING_TONE

    , iAiwMenuHandler( NULL )

#endif

    {

    }

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

// CVcxHgMyVideosVideoListImpl::ConstructL()

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

//

void CVcxHgMyVideosVideoListImpl::ConstructL()

    {

    CVcxHgMyVideosListBase::ConstructL();

    iVideoModel = CVcxHgMyVideosVideoModelHandler::NewL( 

                      *this, iModel, iView, *iScroller );

    iVideoCopier = CVcxHgMyVideosVideoCopier::NewL( *this, *iVideoModel, iModel );

    iUPnP = CVcxHgMyVideosUPnPInterface::NewL( this );

    CFbsBitmap* bitmap( NULL );

    CFbsBitmap* mask( NULL );

    CGulIcon* defaultIcon( NULL );

    // Create default icon for Hg list.

    AknsUtils::CreateIconLC( AknsUtils::SkinInstance(), 

                             KAknsIIDQgnPropMtvProgClip,

                             bitmap,

                             mask,

                             KVcxHgMyVideosMifFile,

                             EMbmVcxhgmyvideosiconsQgn_prop_mtv_prog_clip,

                             EMbmVcxhgmyvideosiconsQgn_prop_mtv_prog_clip_mask );

    TInt error( KErrNone );

    error = AknIconUtils::SetSize( bitmap, 

                                   CHgDoubleGraphicList::PreferredImageSize(), 

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

    User::LeaveIfError( error );

    error = AknIconUtils::SetSize( mask, 

                                   CHgDoubleGraphicList::PreferredImageSize(), 

                                   EAspectRatioPreservedAndUnusedSpaceRemoved );

    User::LeaveIfError( error );

    // Ownership of bitmap and mask is transferred to icon.

    defaultIcon = CGulIcon::NewL( bitmap, mask );

    CleanupStack::Pop( 2 ); // bitmap and mask

    CleanupStack::PushL( defaultIcon );

    // Ownership of icon is transferred.

    iScroller->SetDefaultIconL( defaultIcon );

    CleanupStack::Pop( defaultIcon );

    CGulIcon* ind = iVideoModel->VideoIndicator().VideoOverlayIndicatorL();

    if ( ind )

        {

        CleanupStack::PushL( ind );

        // Ownership of the icon is transferred

        static_cast<CHgDoubleGraphicList*>( iScroller )->SetIconOverlayIndicator( ind );

        CleanupStack::Pop( ind );

        }

    iScroller->SetMarkingObserver( *this );

    iScroller->SetSelectionObserver( *this );

    }

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

// CVcxHgMyVideosVideoListImpl::~CVcxHgMyVideosVideoListImpl()

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

//

CVcxHgMyVideosVideoListImpl::~CVcxHgMyVideosVideoListImpl()

    {

    CloseDeleteWaitNote();

    delete iUPnP;

    delete iVideoCopier;

    delete iVideoModel;

    delete iSendUi;

#ifdef RD_VIDEO_AS_RINGING_TONE

    delete iAiwMenuHandler;

#endif

    }

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

// CVcxHgMyVideosVideoListImpl::DoListActivateL()

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

//

void CVcxHgMyVideosVideoListImpl::DoListActivateL( TInt aIndex )

    {

    TInt index = aIndex;

    index = ( ( index != KErrNotFound ) ? index : iVideoModel->CurrentCategoryIndex() );

    index = ( ( index != KErrNotFound ) ? index : 0 );

    iVideoModel->UpdateVideoListL( index );

    iVideoModel->DoModelActivateL();

    CVcxHgMyVideosListBase::DoListActivateL( index );

    iScroller->SetFocus( ETrue );

    }

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

// CVcxHgMyVideosVideoListImpl::DoListDeactivate()

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

//

void CVcxHgMyVideosVideoListImpl::DoListDeactivate()

    {

    CVcxHgMyVideosListBase::DoListDeactivate();

    iVideoModel->DoModelDeactivate();

    iScroller->SetFocus( EFalse );

    }

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

// CVcxHgMyVideosVideoListImpl::VideoModel()

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

//

CVcxHgMyVideosVideoModelHandler& CVcxHgMyVideosVideoListImpl::VideoModel()

    {

    return *iVideoModel;

    }

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

// CVcxHgMyVideosVideoListImpl::UPnPInterface()

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

//

CVcxHgMyVideosUPnPInterface& CVcxHgMyVideosVideoListImpl::UPnPInterface()

    {

    return *iUPnP;

    }

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

// CVcxHgMyVideosVideoListImpl::HandleSelectL()

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

//

void CVcxHgMyVideosVideoListImpl::HandleSelectL( TInt /*aIndex*/ )

    {

	iView.DynInitMskL();

    }

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

// CVcxHgMyVideosVideoListImpl::HandleOpenL()

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

//

void CVcxHgMyVideosVideoListImpl::HandleOpenL( TInt /*aIndex*/ )

    {

    if ( iModel.TouchSupport() )

        {    

        PlayCurrentVideoL();

        }

    }

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

// CVcxHgMyVideosVideoListImpl::HandleMarkingL()

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

//

void CVcxHgMyVideosVideoListImpl::HandleMarkingL( TInt /*aIndex*/, TBool /*aMarked*/ )

    {    

    iView.DynInitMskL();

    }

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

// CVcxHgMyVideosVideoListImpl::Highlight()

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

//

TInt CVcxHgMyVideosVideoListImpl::Highlight()

    {

    return iVideoModel->Highlight();

    }

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

// CVcxHgMyVideosVideoListImpl::GetOperationTargetIndexesL()

// Returns the index(es) of videos that should be the target for user's 

// operation.

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

//

void CVcxHgMyVideosVideoListImpl::GetOperationTargetIndexesL( 

        RArray<TInt>& aOperationTargets )

    {

    iVideoModel->MarkedVideosL( aOperationTargets );

    if ( aOperationTargets.Count() == 0 )

        {

        TInt highlight = Highlight();

        if ( highlight == KErrNotFound )

            {

            User::Leave( KErrNotFound );

            }

        aOperationTargets.AppendL( highlight );

        }

    }

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

// CVcxHgMyVideosVideoListImpl::PlayCurrentVideoL()

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

//

void CVcxHgMyVideosVideoListImpl::PlayCurrentVideoL()

    {

    PlayVideoL();

    }

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

// CVcxHgMyVideosVideoListImpl::DeleteVideosL()

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

//

void CVcxHgMyVideosVideoListImpl::DeleteVideosL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CVcxHgMyVideosVideoListImpl::DeleteVideosL()" );

    RArray<TInt> operationTargetIndexes;

	RArray<TInt> operationTargetIds;

    CleanupClosePushL( operationTargetIndexes );

    CleanupClosePushL( operationTargetIds );

    GetOperationTargetIndexesL( operationTargetIndexes );

    OperationTargetsToMpxIdsL( operationTargetIndexes, operationTargetIds );

    if ( ConfirmDeleteVideosL( operationTargetIndexes.Count(),

                               iVideoModel->GetVideoName( operationTargetIds[0] ) ) )

        {

        HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );

        // Wait note is closed in destructor (CloseDeleteWaitNote()), 

        // in DialogDismissedL() or in VideoDeletionCompletedL().

        OpenDeleteWaitNoteL();

        TRAPD( err, iVideoModel->DeleteVideosL( operationTargetIds ) );

        if( err != KErrNone )

            {

            CloseDeleteWaitNote();

            }

        }

    CleanupStack::PopAndDestroy( &operationTargetIds );

    CleanupStack::PopAndDestroy( &operationTargetIndexes );

    }

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

// CVcxHgMyVideosVideoListImpl::ConfirmDeleteVideosL()

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

//

TBool CVcxHgMyVideosVideoListImpl::ConfirmDeleteVideosL( TInt aTargetCount,

                                                         const TDesC& aTargetName )

    {

    HBufC* text = NULL;

    if ( aTargetCount == 1 )

        {

        text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_QUERY_COMMON_CONF_DELETE, aTargetName );

        }

    else if ( aTargetCount > 1 )

        {

        text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_DEL_ITEMS_QUERY, aTargetCount );

        }

    if ( text )

        {

        CAknQueryDialog* dlg = CAknQueryDialog::NewL();

        TInt result = dlg->ExecuteLD( R_VCXHGMYVIDEOS_DELETE_CONFIRMATION_QUERY, *text );

        CleanupStack::PopAndDestroy( text );

        if ( result == EAknSoftkeyYes || result == EAknSoftkeyOk )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CVcxHgMyVideosVideoListImpl::OpenDeleteWaitNoteL()

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

//

void CVcxHgMyVideosVideoListImpl::OpenDeleteWaitNoteL()

    {

    CloseDeleteWaitNote();

    iDeleteWaitDialog = new (ELeave) 

            CAknWaitDialog( ( REINTERPRET_CAST( CEikDialog**, &iDeleteWaitDialog ) ), ETrue );

    iDeleteWaitDialog->SetCallback( this );

    iDeleteWaitDialog->ExecuteLD( R_VCXHGMYVIDEOS_DELETING_WAIT_NOTE );

    }

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

// CVcxHgMyVideosVideoListImpl::CloseDeleteWaitNote()

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

//

void CVcxHgMyVideosVideoListImpl::CloseDeleteWaitNote()

    {

    if ( iDeleteWaitDialog )

        {

        TRAPD( error, iDeleteWaitDialog->ProcessFinishedL() );

        if ( error != KErrNone )

            {

            delete iDeleteWaitDialog;

            }

        iDeleteWaitDialog = NULL;

        }

    }

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

// CVcxHgMyVideosVideoListImpl::CommandComplete()

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

//

void CVcxHgMyVideosVideoListImpl::CommandComplete( TInt /*aStatusCode*/ )

    {

    // status larger than KErrNone does not require any attention.

    }

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

// CVcxHgMyVideosVideoListImpl::DialogDismissedL()

// Callback about (delete) wait note dismissal.

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

//

void CVcxHgMyVideosVideoListImpl::DialogDismissedL( TInt aButtonId )

    {

    if ( aButtonId == EAknSoftkeyCancel )

        {

        iModel.CollectionClient().CancelDeleteVideosL();

        }

    iDeleteWaitDialog = NULL;

    }

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

// CVcxHgMyVideosVideoListImpl::VideoDeletionCompletedL()

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

// 

void CVcxHgMyVideosVideoListImpl::VideoDeletionCompletedL( TInt aFailedCount,

                                                           const TDesC& aFailedName )

    {

    CloseDeleteWaitNote();

    if ( aFailedCount > 0 )

        {

        HBufC* text = NULL;

        if ( aFailedCount == 1 )

            {

            text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_FLDR_CANT_DELETE_FILE_OPEN, aFailedName );

            }

        else

            {

            text = StringLoader::LoadLC( R_VCXHGMYVIDEOS_CANT_DELETE_ITEMS );

            }

        CAknErrorNote* note = new ( ELeave ) CAknErrorNote( ETrue );

        note->ExecuteLD( *text );

        CleanupStack::PopAndDestroy( text );  

        }    

    }

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

// CVcxHgMyVideosVideoListImpl::PlayVideoL()

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

//

void CVcxHgMyVideosVideoListImpl::PlayVideoL()

    {

    RArray<TInt> operationTargets;

    CleanupClosePushL( operationTargets );

    GetOperationTargetIndexesL( operationTargets );

    HandleMarkCommandL( EVcxHgMyVideosCmdUnmarkAll );

    // Currently only play one video

    // Need to handle multiply selected videos

    for ( TInt i = operationTargets.Count() - 1; i >= 0; i-- )

        {

        if( !iUPnP->IsStarted() )

            {

            iVideoModel->PlayVideoL( operationTargets[i] );

            iModel.SetAppState( CVcxHgMyVideosModel::EVcxMyVideosAppStatePlayer );

            }

        else // UPnP started

            {

            TInt err(KErrNone); 

            err = iUPnP->ShowVideo( iVideoModel->GetVideoUri( operationTargets[0] ) );

            if( err != KErrNone )

                {

                // some general upnp framework error, 

                // call stop to deallocate

                iUPnP->Stop();

                }

            }        

        break;

        }

    CleanupStack::PopAndDestroy( &operationTargets );

    }

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

// CVcxHgMyVideosVideoListImpl::ResumeDownloadL()

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

//

void CVcxHgMyVideosVideoListImpl::ResumeDownloadL()

    {

    iVideoModel->ResumeDownloadL( Highlight() );

    }

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

// CVcxHgMyVideosVideoListImpl::CancelDownloadL()

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

//

void CVcxHgMyVideosVideoListImpl::CancelDownloadL()

    {

    iVideoModel->CancelDownloadL( Highlight() );   

    }

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

// CVcxHgMyVideosVideoListImpl::HandleSortCommandL()