/*

* Copyright (c) 2006 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 Podcast Collection view

*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <aknViewAppUi.h>

#include <eikmenub.h>

#include <StringLoader.h>

#include <aknnavilabel.h>

#include <aknnavide.h>

#include <eikapp.h>

#include <AknUtils.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>   // Icon no skin

#include <akntitle.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <aknnavi.h>

#include <hlplch.h>

#include <bautils.h>

#include <eikspmod.h>

#include <eikclb.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <sendui.h>

#include <CMessageData.h>

#include <centralrepository.h>

#include <avkon.rsg>

#include <eikbtgpc.h>

#include <AknWaitDialog.h>

#include <apgcli.h>     // RApaLsSession

#include <akncontext.h> // Context Pane

#include <fbs.h>        // CFbsBitmap

#include <bldvariant.hrh>

#include <coeutils.h>

#include <AknDlgShut.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include <mpxuser.h>

#ifdef UPNP_INCLUDED

#include <upnpcopycommand.h>

#endif

#include <e32const.h>

#include <AiwServiceHandler.h>  //Copy to remote feature

//#ifdef __COVER_DISPLAY

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include "mplayersecondarydisplayapi.h"

//#endif

#include <mpxappui.hrh>

#include <data_caging_path_literals.hrh>

#include <layoutmetadata.cdl.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxcollectionmessage.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxpodcastcollectionview.rsg>

#include <mpxcollectionview.mbg>

#include <mpxcollectionutility.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxmedia.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplaylist.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediaarray.h>

#include <mpxpodcastdefs.h> // Podcast specific

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxconstants.h>

#include "mpxwaitnotedefs.h"

#include <mpxinternalcrkeys.h>

#include "mpxpodcastcollectionviewlistboxarray.h"

#include "mpxcommoncontainer.hrh"

#include "mpxcommoncontainer.h"

#include "mpxcommonuihelper.h"

#include "mpxpodcastcollectionviewcontainer.h"

#include "mpxpodcastcollectionview.hrh"

#include "mpxpodcastcollectionview.hlp.hrh"

#include "mpxpodcastcollectionviewimp.h"

#include "mpxlog.h"

#include "mpxviewprivatepskeys.h"

// CONSTANTS

_LIT(KMPXPodcastCollectionRscPath, "mpxpodcastcollectionview.rsc");

// Nokia Podcasting Application Uid

const TUid KNPodAppUid = { 0x1028190B };

const TInt KMilliSecondsToSeconds(1000);

const TInt KMPXMaxBufferLength(160);

const TInt KMPXMaxTimeLength(36);

const TInt KMPXDurationDisplayResvLen(10);

const TInt KPodcastCollectionMenuLevel( 2 );

//#ifdef __UPNP_FRAMEWORK_2_0_

const TInt KMPXLastDirectoryLevel( 2 );

//#endif //__UPNP_FRAMEWORK_2_0_

// MACROS

_LIT(KMPXCollDetailsItemsFormat, "%S\t%S");

#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

#define KMusicCollectionUid 0x101FFC3A

#endif

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

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

// Two-phased constructor.

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

//

CMPXPodcastCollectionViewImp* CMPXPodcastCollectionViewImp::NewL()

    {

    MPX_FUNC("CMPXPodcastCollectionViewImp::NewL");

    CMPXPodcastCollectionViewImp* self = CMPXPodcastCollectionViewImp::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXPodcastCollectionViewImp* CMPXPodcastCollectionViewImp::NewLC()

    {

    CMPXPodcastCollectionViewImp* self = new (ELeave) CMPXPodcastCollectionViewImp();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp()

    {

    MPX_DEBUG1("CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp entering");

    if (iCollectionUtility)

        {

        iCollectionUtility->Close();

        }

    if (iPlaybackUtility)

        {

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

        }

    if (iViewUtility)

        {

        iViewUtility->Close();

        }

    if (iCollectionUiHelper)

        {

        iCollectionUiHelper->Close();

        }

    if ( iUpnpFrameworkSupport )

        {

        MPX_DEBUG1(_L("CMPXCollectionViewImp::~CMPXCollectionViewImp Detaching 'Copy to external' menu service..."));

        if ((iServiceHandler) &&

             (iCurrentlyAttachedCopyToMenuPane != KErrNotFound))

            {

            iServiceHandler->DetachMenu(iCurrentlyAttachedCopyToMenuPane,

                                 R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST);

            }

        delete iServiceHandler;

        iPlayersList.Close();

        delete iSubPlayerName;

        }

#ifdef UPNP_INCLUDED

    if (iUpnpCopyCommand)

        {

        delete iUpnpCopyCommand;

        }

#endif

    if (iResourceOffset)

        {

        iEikonEnv->DeleteResourceFile(iResourceOffset);

        }

    if (iContainer)

        {

        AppUi()->RemoveFromStack( iContainer->Common()->CoeControl() );

        delete iContainer;

        }

    if (iNaviDecorator)

        {

        delete iNaviDecorator;

        }

    if (iMediaToSet)

        {

        delete iMediaToSet;

        }

    delete iCommonUiHelper;

    delete iSendUi;

    delete iTitle;

    delete iNumEpisode;

    delete iDuration;

    delete iOriginalTitle;

    delete iOriginalDuration;

    delete iBottomIndex;

    delete iCba;

    MPX_DEBUG1("CMPXPodcastCollectionViewImp::~CMPXPodcastCollectionViewImp exiting");

    }

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

// Delete the selected items

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

//

void CMPXPodcastCollectionViewImp::DeleteSelectedItemsL()

    {

    MPX_FUNC("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL");

    TBool isIgnore(EFalse);

    if (iContainer->Common()->CurrentListItemCount() == 0)

        {

        // list is empty

        isIgnore = ETrue;

        }

    if (!isIgnore)

        {

        CMPXCommonListBoxArrayBase* listboxArray =

            iContainer->Common()->ListBoxArray();

        TInt currentIndex = iContainer->Common()->CurrentLbxItemIndex();

        // Create a copy of collection path

        CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

        CleanupStack::PushL(path);

        CAknQueryDialog* confirmationDlg = NULL;

        HBufC* promptTxt = NULL;

        HBufC* waitNoteText = NULL;

//        TInt waitNoteCBA = R_AVKON_SOFTKEYS_EMPTY;

        // Marked indicies

        const CArrayFix<TInt>* array =

            iContainer->Common()->CurrentSelectionIndicesL();

        TInt arrayCount = array->Count();

        MPX_DEBUG2("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL delete array count = %d", arrayCount);

        if ( arrayCount > 1 )

            {

            waitNoteText = StringLoader::LoadLC(

                R_MPX_QTN_NMP_DEL_SONGS_WAIT_NOTE);

            promptTxt = StringLoader::LoadLC(

                R_MPX_QTN_NMP_DEL_SONGS_QUERY,

                    arrayCount);

//            waitNoteCBA = R_MPX_COLLECTION_WAITNOTE_SOFTKEYS_EMPTY_STOP;

            confirmationDlg = CAknQueryDialog::NewL(

                CAknQueryDialog::EConfirmationTone);

            CleanupStack::PushL(confirmationDlg);

//#ifdef __COVER_DISPLAY

            confirmationDlg->PublishDialogL(

                EMPlayerQueryDeleteTracks,

                KMPlayerNoteCategory);

            CAknMediatorFacade* covercl =

                AknMediatorFacade(confirmationDlg);

            if (covercl)

                {

                covercl->BufStream().WriteInt32L(arrayCount);

                }

//#endif //__COVER_DISPLAY

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

                {

                MPX_DEBUG2("CMPXPodcastCollectionViewImp::DeleteSelectedItemsL delete array index = %d", array->At(i));

                path->SelectL(array->At(i));

                }

            }

        else

            {

            const CMPXMedia& media( listboxArray->MediaL(

                ( arrayCount > 0 ) ? array->At( 0 ) : currentIndex ) );

            const TDesC& title = media.ValueText(KMPXMediaGeneralTitle);

            TMPXGeneralType type = EMPXNoType;

            TMPXGeneralCategory category = EMPXNoCategory;

            if (media.IsSupported(KMPXMediaGeneralType))

                {

                type =

                    media.ValueTObjectL<TMPXGeneralType>(KMPXMediaGeneralType);

                }

            if (media.IsSupported(KMPXMediaGeneralCategory))

                {

                category =

                    media.ValueTObjectL<TMPXGeneralCategory>(KMPXMediaGeneralCategory);

                }

            if (type == EMPXItem && category == EMPXPodcast)

                {

                // tracks level

                waitNoteText = StringLoader::LoadLC(

                        R_MPX_QTN_ALBUM_WAITING_DELETING, title);

                promptTxt = StringLoader::LoadLC(

                    R_MPX_QTN_QUERY_COMMON_CONF_DELETE,

                    title);

                }

            else

                {

                waitNoteText = StringLoader::LoadLC(

                        R_MPX_QTN_MUS_QUERY_CONF_DELETE_ALL, title);

//                waitNoteCBA = R_MPX_COLLECTION_WAITNOTE_SOFTKEYS_EMPTY_STOP;

                promptTxt = StringLoader::LoadLC(

                    R_MPX_QTN_NMP_QUERY_CONF_DELETE_GROUP,

                    title);

                }

            confirmationDlg = CAknQueryDialog::NewL(

                CAknQueryDialog::EConfirmationTone);

            CleanupStack::PushL(confirmationDlg);

//#ifdef __COVER_DISPLAY

            if (type == EMPXItem && category == EMPXPodcast)

                {

                // tracks level

                confirmationDlg->PublishDialogL(

                    EMPlayerQueryDeleteCategory,

                    KMPlayerNoteCategory);

                }

            else

                {

                confirmationDlg->PublishDialogL(

                    EMPlayerQueryDeleteTrack,

                    KMPlayerNoteCategory);

                }

            CAknMediatorFacade* covercl =

                AknMediatorFacade(confirmationDlg);

            if (covercl)

                {

                covercl->BufStream() << title;

                }

//#endif //__COVER_DISPLAY

            path->Set( arrayCount > 0 ? array->At( 0 ) : currentIndex );

            }

        confirmationDlg->SetPromptL(*promptTxt);

        CleanupStack::Pop(confirmationDlg);

        CleanupStack::PopAndDestroy(promptTxt);

        if (confirmationDlg->ExecuteLD(R_MPX_CUI_DELETE_CONFIRMATION_QUERY))

            {

            HandleCommandL( EMPXCmdIgnoreExternalCommand );

            StartDeleteWaitNoteL();

            TPtr buf = waitNoteText->Des();

			UpdateProcessL(buf);

            iCollectionUiHelper->DeleteL(*path, this);

            iIsDeleting = ETrue;

          }

        CleanupStack::PopAndDestroy(waitNoteText);

        CleanupStack::PopAndDestroy(path);

        }

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPXPodcastCollectionViewImp::CMPXPodcastCollectionViewImp()

    : iMediaToSet(NULL)

    , iCurrNotYetPlayedListIndex(-1)

#ifdef __ENABLE_MSK

    , iCurrentMskId(KErrNotFound)

    , iShowContextMenu(EFalse)

#endif // __ENABLE_MSK

    {

    MPX_FUNC("CMPXPodcastCollectionViewImp::CMPXPodcastCollectionViewImp");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXPodcastCollectionViewImp::ConstructL()

    {

    MPX_FUNC("CMPXPodcastCollectionViewImp::ConstructL");

    CCoeEnv* coeEnv( iEikonEnv );

    TParse parse;

    parse.Set(KMPXPodcastCollectionRscPath, &KDC_APP_RESOURCE_DIR, NULL);

    TFileName resourceFile(parse.FullName());

    User::LeaveIfError(MPXUser::CompleteWithDllPath(resourceFile));

    BaflUtils::NearestLanguageFile(coeEnv->FsSession(), resourceFile);

    iResourceOffset = coeEnv->AddResourceFileL(resourceFile);

    BaseConstructL(R_MPX_PODCAST_COLLECTION_VIEW);

    // Get the collection utility instance from engine.

    iCollectionUtility = MMPXCollectionUtility::NewL(this, KMcModeDefault);

    iBackOneLevel = EFalse;

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iViewUtility = MMPXViewUtility::UtilityL();

    iViewUtility->AddObserverL(this);

    iBottomIndex = new (ELeave) CArrayFixFlat<TInt>(1);

    iCommonUiHelper = CMPXCommonUiHelper::NewL(iCollectionUtility);

    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    // Monitor for view activation

    AppUi()->AddViewActivationObserverL( this );

#ifdef UPNP_INCLUDED

  	if(!iUpnpCopyCommand)

  	    {

  	    MPX_TRAPD ( error, iUpnpCopyCommand = CUpnpCopyCommand::NewL() );   

		    if ( error == KErrNone )

            {

            iUpnpFrameworkSupport = ETrue;

            iServiceHandler = CAiwServiceHandler::NewL();

            MPX_DEBUG1("CMPXPodcastCollectionViewImp::ConstructL() Attaching 'Copy to external' menu service...");

            MPX_TRAP(iErrorAttachCopyMenu, iServiceHandler->AttachMenuL(R_MPX_PODCAST_COLLECTION_VIEW_MENU_1,

                                                   R_MPX_UPNP_COPY_TO_EXTERNAL_MENU_INTEREST));

            if ( iErrorAttachCopyMenu == KErrNotSupported )

                {

                // when CCoeEnv is not available

                User::Leave( iErrorAttachCopyMenu );

                }

            MPX_DEBUG2("CMPXPodcastCollectionViewImp::ConstructL(): attach Copy menu error: %d", iErrorAttachCopyMenu);

            }

        else

            {

            iUpnpFrameworkSupport = EFalse;

			iUpnpCopyCommand = NULL;

            }

        }

#endif

    TUid naviPaneUid;

    naviPaneUid.iUid = EEikStatusPaneUidNavi;

    iNaviPane =

        static_cast<CAknNavigationControlContainer*>

        (iAvkonViewAppUi->StatusPane()->ControlL(naviPaneUid));

    iNaviDecorator = iNaviPane->CreateNavigationLabelL(KNullDesC);

    //Create label to change text in Navi pane

    iNaviLabel = static_cast<CAknNaviLabel*>

            (iNaviDecorator->DecoratedControl());

    TInt flags(0);

    CRepository* repository = CRepository::NewL(KCRUidMPXMPFeatures);

    repository->Get(KMPXMPLocalVariation, flags);

    delete repository;

    iChangeRTForAllProfiles =

        static_cast<TBool>(flags & KMPXChangeRTForAll);

    iLastDepth = 1;

    MPX_DEBUG2("CMPXPodcastCollectionViewImp::ConstructL iLastDepth = %d", iLastDepth);

    iBottomIndex->AppendL(0);

#ifdef _DEBUG

    iExitOptionHidden = EFalse;

#else // _DEBUG

    iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL();

#endif // _DEBUG

    // used to know if HandleOpen was called -> we cannot update the playback

    // status of listbox items before the list box is updated in HandleOpen

    iHandleOpenProcessed = EFalse;

    iSelectedItem = KMPXInvalidItemId;

    }

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

// Updates list box

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

//

void CMPXPodcastCollectionViewImp::UpdateListBoxL(

    CMPXMedia& aEntries,

    TInt aIndex)

    {

    MPX_FUNC("CMPXPodcastCollectionViewImp::UpdateListBox");

    MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateListBox aIndex = %d", aIndex);

    if (iContainer)

        {

        CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();

        CleanupStack::PushL(cpath);

        CMPXCommonListBoxArrayBase* array =

            iContainer->Common()->ListBoxArray();

        array->ResetMediaArrayL();

        iContainer->Common()->HandleLbxItemRemovalL();

        array->AppendMediaL(aEntries);

        // this needs to be before HandleLbxItemAdditionL so that the items

        // are redrawn properly after playback status has been updated.

        UpdatePlaybackStatusL(EFalse);

        iContainer->Common()->HandleLbxItemAdditionL();

        MPX_DEBUG2("CMPXPodcastCollectionViewImp::UpdateListBox List box contains %d items", iContainer->Common()->TotalListItemCount());

        // Display empty List Box string if list box is empty

        // Display different empty string if Podcast App does not exist

        HBufC* emptyText = NULL;

        if (CheckPodcastAppL() == KErrNone)

            {

            emptyText = StringLoader::LoadLC(