/*

* 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 UPnP players browse Dialog

*

*/

// INCLUDE FILES

#include <aknPopupHeadingPane.h>

#include <aknPopup.h>

#include <aknlists.h>

#include <AknIconArray.h>

#include <gulicon.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>  // KDC_APP_RESOURCE_DIR

#include <bautils.h>  // BaflUtils

#include <AknsConstants.h>

#include <aknnotewrappers.h>

#include "mpxupnpbrowsedialog.h"

#include <mpxupnpbrowsedialog.rsg>

#include <mpxmessagegeneraldefs.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include "mpxplayermanagerstub.h"

#include "mpxlog.h"

#include <aknconsts.h>

#include <avkon.mbg>

#include <errorres.rsg>

#include <wlanerrorcodes.h>

#include <mpxmedia.h>

#include <mpxplaybackutility.h> // MMPXPlayerManager, MMPXPlaybackUtility

#include <mpxplaybackmessage.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxcommandgeneraldefs.h> // KMPXCommandGeneralDoSync

#include <mpxcollectionplaylist.h>

#include <mpxuser.h>

// CONSTANTS

_LIT( KMPlayerUPnPBrowserDialogRscPath, "mpxupnpbrowsedialog.rsc" );

_LIT( KUPnPBrowseListboxString, "%S\t%d\t" );

_LIT(KTab,"\t");

_LIT(KSpace, " ");

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

// CMPXUPnPBrowseDialog::NewL

// Two-phased constructor.

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

EXPORT_C CMPXUPnPBrowseDialog* CMPXUPnPBrowseDialog::NewL(TInt aPlayerUid)

    {

    CMPXUPnPBrowseDialog* self = new (ELeave) CMPXUPnPBrowseDialog(aPlayerUid);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CMPXUPnPBrowseDialog::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CMPXUPnPBrowseDialog::ConstructL( )

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::ConstructL" );

    // Get the playback utility instance from engine.

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    // Load resource file

    //

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

    BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(),

                                    resourceFile );

    iResourceOffset = CCoeEnv::Static()->AddResourceFileL( resourceFile );

    iViewUtility = MMPXViewUtility::UtilityL();

    }

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

// CMPXUPnPBrowseDialog::CMPXUPnPBrowseDialog

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

// might leave.

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

CMPXUPnPBrowseDialog::CMPXUPnPBrowseDialog(TInt aPlayerUid) :

    iPlayerUid(aPlayerUid)

    {

    }

// Destructor

CMPXUPnPBrowseDialog::~CMPXUPnPBrowseDialog()

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::Destructor" );

    if (iResourceOffset)

        {

        CCoeEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    delete iListBox;

    //Already cancelled in the destructor

    delete iPlayerManagerStub;

    if ( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    delete iCurrentlySelectedSubPlayerName;

    if ( iViewUtility )

        {

        iViewUtility->Close();

        }

    }

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

// Executes the popup list

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

//

EXPORT_C TInt CMPXUPnPBrowseDialog::ExecuteLD(TInt aPlayerUid)

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::ExecuteLD()" );

    TInt errorSelectSubPlayer = KErrNone;

    TBool okToExit = EFalse;

    TInt selectedSubplayerIndex = KErrNotFound;

    iPlayerUnavailableError = EFalse;

    iPlayerUid = aPlayerUid;

    while ( !okToExit )

        {

        RetrieveCurrentlySelectSubplayerNameL();

    	CreatePopupL();

        TInt returnValue = StartPopupL();

        MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() after StartPopupL() returnValue %d", returnValue );

        // if 1, Select was pressed

        if ( returnValue )

            {

            TInt currentItemIndex = iListBox->CurrentItemIndex();

            TInt numberOfItems = iListBox->Model()->NumberOfItems();

            // check for boundaries

            // if currentItemIndex is valid

            if ( ( currentItemIndex >= 0 ) &&

                 ( currentItemIndex < numberOfItems ) )

                {

                MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() currentItemIndex %d", currentItemIndex );

                MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() numberOfItems %d", numberOfItems );

                // if a subplayer was selected (and not <search again>)

                HBufC* listText =

                        StringLoader::LoadLC(R_UPNP_LIST_UPNP_MORE_SUBPLAYERS);

                TInt isSelectedItemASubplayerName =

                        listText->CompareF(

                             (iListBox->Model()->ItemText(currentItemIndex)) );

                MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() isSelectedItemASubplayerName %d", isSelectedItemASubplayerName );

                CleanupStack::PopAndDestroy( listText );

                if ( isSelectedItemASubplayerName )

                    {

                    if ( iPlaybackUtility )

                        {

                        iPlaybackUtility->CancelRequest();

                        }

                    TBool selecDifferentSubPlayer = ETrue;

                    if ( iCurrentlySelectedSubPlayerName )

                        {

                        TFileName listName(iListBox->Model()->ItemText(currentItemIndex));

                        TInt index = listName.Find(KTab);

                        if ( index >= 0 )

                            {

                            TFileName subPlayerName = listName.LeftTPtr(index);

                            selecDifferentSubPlayer =

                              ( ( subPlayerName.CompareF(

                                  *iCurrentlySelectedSubPlayerName ) ) &&

                                  ( aPlayerUid == iCurrentlyUsedPlayer.iUid) );

                            }

                        else

                            {

                            selecDifferentSubPlayer =

                              ( ( listName.CompareF(

                                  *iCurrentlySelectedSubPlayerName ) ) &&

                                  ( aPlayerUid == iCurrentlyUsedPlayer.iUid) );

                            }

                        MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() selecDifferentSubPlayer %d", selecDifferentSubPlayer);

                        }

                    if(iPlaybackUtility)

                        {

                        MMPXSource* source = iPlaybackUtility->Source();

                        CMPXCollectionPlaylist* playlist = NULL;

                        if ( source )

                            {

                            playlist = source->PlaylistL();

                            if ( playlist )

                                {

                                CleanupStack::PushL( playlist );

                                }

                            }

                        MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

                        // user selects a different remote player

                        if ( iCurrentlySelectedSubPlayerName &&

                                selecDifferentSubPlayer )

                            {

                            // need to clean up the current plugin

                            TRAP_IGNORE( manager.ClearSelectPlayersL() );

                            }

                        MPX_DEBUG3( "CMPXUPnPBrowseDialog::ExecuteLD() before call to manager.SelectSubPlayerL(%d, %d)", iPlayerUid, currentItemIndex );

                        MPX_TRAP( errorSelectSubPlayer,

                                manager.SelectSubPlayerL( TUid::Uid(iPlayerUid),

                                        currentItemIndex ) );

                        MPX_DEBUG2( "CMPXUPnPBrowseDialog::ExecuteLD() after manager.SelectSubPlayerL()", errorSelectSubPlayer );

                        if ( errorSelectSubPlayer == KErrNone )

                            {

                            okToExit = ETrue;

                            if ( selecDifferentSubPlayer )

                                {

                                selectedSubplayerIndex = currentItemIndex;

                                }

                            else // subplayer selected is the same as the current one

                                {

                                selectedSubplayerIndex = KErrInUse;

                                }

                            }

                        else

                            {

                            TRAP_IGNORE( manager.ClearSelectPlayersL() );

                            if ( playlist )

                                {

                                iPlaybackUtility->InitL( *playlist, EFalse );

                                }

                            DisplayErrorNoteL( R_UPNP_ERROR_PLAYER_UNAVAILABLE );

                            }

                        if ( playlist )

                            {

                            CleanupStack::PopAndDestroy( playlist );

                            }

                        }

                    else

                        {

                        // Should not reach here  

                        MPX_DEBUG1( "CMPXUPnPBrowseDialog::ExecuteLD()playbackutility is NULL" );

                        }     

                    } // if ( isSelectedItemASubplayerName )

                } // check for boundaries

            else

                {

                okToExit = ETrue;

                selectedSubplayerIndex = KErrCancel;

                }

            } // if ( returnValue )

        else // Cancel was selected

            {

            if ( !iPlayerUnavailableError )

                {

                if ( iPlaybackUtility )

                    {

                    iPlaybackUtility->CancelRequest();

                    }

                CMPXCommand* cmd = CMPXCommand::NewL();

                CleanupStack::PushL(cmd);

                cmd->SetTObjectValueL<TInt>(KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral);

                // All of current commands are sync

                cmd->SetTObjectValueL<TBool>(KMPXCommandGeneralDoSync, ETrue);

                cmd->SetTObjectValueL<TInt>(KMPXCommandPlaybackGeneralType, EPbCmdUnloadNonActivePlugin);

                cmd->SetTObjectValueL<TInt>(KMPXCommandPlaybackGeneralData, aPlayerUid);

                if(iPlaybackUtility)

                 {

                  iPlaybackUtility->CommandL(*cmd, NULL);

                 } 

                CleanupStack::PopAndDestroy(cmd);

                okToExit = ETrue;

                selectedSubplayerIndex = KErrCancel;

                }

            // else we display the popup again

            else

                {

                iPlayerUnavailableError = EFalse;

                }

            }

        } // while ( !okToExit )

    return selectedSubplayerIndex;

    }

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

// CMPXUPnPBrowseDialog::PreLayoutDynInitL();

// called by framework before dialog is shown

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

void CMPXUPnPBrowseDialog::PreLayoutDynInitL()

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::PreLayoutDynInitL()" );

    // Browse dialog title text

    HBufC* dialogTitle = StringLoader::LoadLC(R_UPNP_MENU_TITLE_SELECT_PLAYER);

    iPopup->SetTitleL(*dialogTitle);

    CleanupStack::PopAndDestroy(dialogTitle);

    // Previous UPNP code

    CAknIconArray* icons = new ( ELeave ) CAknIconArray(2);

    CleanupStack::PushL(icons);

    // Mif icons

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath( AknIconUtils::AvkonIconFileName( ) );

    // Media server icon

    AppendIconToArrayL( icons, skin,

                        KAvkonBitmapFile,

                        KAknsIIDQgnIndiMarkedAdd,

                        EMbmAvkonQgn_indi_marked_add,

                        EMbmAvkonQgn_indi_marked_add_mask );

    iListBox->ItemDrawer()->FormattedCellData()->SetIconArrayL( icons );

    CleanupStack::Pop(icons);

    // Previous UPNP code

    LoadListItemsL();

    }

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

// CUPnPBrowsePopup::LoadListItemsL

// Sends the browse request to MPXPlayerManager. When result set arrives,

// Playback callback will call the "HandleSubPlayerNamesL" call back method,

// which is implemented below.

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

void CMPXUPnPBrowseDialog::LoadListItemsL()

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::LoadListItemsL()" );

    MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

    DisplayWaitingTextL();

    if ( iPlayerManagerStub )

        {

        iPlayerManagerStub->SubPlayerNamesL(*this, TUid::Uid(iPlayerUid));

        }

    else

        {

        MPX_DEBUG1( "CMPXUPnPBrowseDialog::LoadListItemsL() before call to manager.SubPlayerNamesL()" );

        manager.SubPlayerNamesL(*this, TUid::Uid(iPlayerUid));

        }

    }

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

// CUPnPBrowsePopup::DisplaySubPlayersNamesL

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

void CMPXUPnPBrowseDialog::DisplaySubPlayersNamesL( const MDesCArray* aSubPlayers,

                                                    const TBool aComplete )

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::DisplaySubPlayersNamesL()" );

    CTextListBoxModel* model = iListBox->Model();

    MDesCArray* textArray = model->ItemTextArray();

    CDesCArray* listBoxItems = static_cast<CDesCArray*>(textArray);

    TInt subPlayersCount = 0;

    listBoxItems->Reset();

    if ( aSubPlayers )

        {

        subPlayersCount = aSubPlayers->MdcaCount();

        MPX_DEBUG2( "CMPXUPnPBrowseDialog::DisplaySubPlayersNamesL(), aSubPlayer exists %d",

                    subPlayersCount );

        if ( subPlayersCount > 0 )

            {

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

                {

                TPtrC temp = aSubPlayers->MdcaPoint(i);

                TFileName subPlayerName;

                subPlayerName.Copy(temp);

                subPlayerName.TrimAll();        // trim all leading and trailing spaces (including tab)

                TInt tabPos = subPlayerName.Find(KTab);

                // replace tab with single space

                while (tabPos != KErrNotFound)

                    {

                    subPlayerName.Replace(tabPos, 1, KSpace);

                    tabPos = subPlayerName.Find(KTab);

                    }                

                // Append name of the subplayer in the listbox

                if ( iCurrentlySelectedSubPlayerName )

                    {

                    if ( !subPlayerName.CompareF( *iCurrentlySelectedSubPlayerName ) )

                        {

                        // names are the same and we add the selection icon

                        TFileName item;

                        item.Format(KUPnPBrowseListboxString, &subPlayerName, 0);

                        listBoxItems->AppendL(item);

                        }

                    else

                        {

                        listBoxItems->AppendL(subPlayerName);

                        }

                    }

                else

                    {

                    listBoxItems->AppendL(subPlayerName);

                    }

                }

            // if search is complete we add the <search again> listbox item last

            if ( aComplete )

                {

                HBufC* listText = StringLoader::LoadLC(R_UPNP_LIST_UPNP_MORE_SUBPLAYERS);

                listBoxItems->AppendL(*listText);

                CleanupStack::PopAndDestroy( listText );

                }

            iPopup->ButtonGroupContainer()->SetCommandSetL(

                                                R_AVKON_SOFTKEYS_SELECT_CANCEL);

            iPopup->ButtonGroupContainer()->DrawDeferred();

            iListBox->HandleItemAdditionL(); // Update listbox

            iListBox->SetCurrentItemIndexAndDraw(0); // select new item

            }

        }

    if ( !aSubPlayers || (subPlayersCount <= 0) )

        {

        if ( aComplete ) // search is complete

            {

            HBufC* searchAgainText = StringLoader::LoadLC(R_UPNP_LIST_UPNP_MORE_SUBPLAYERS);

            listBoxItems->AppendL(*searchAgainText);

            CleanupStack::PopAndDestroy(searchAgainText);

            iPopup->ButtonGroupContainer()->SetCommandSetL(

                                                R_AVKON_SOFTKEYS_SELECT_CANCEL);

            iPopup->ButtonGroupContainer()->DrawDeferred();

            iListBox->HandleItemAdditionL(); // Update listbox

            iListBox->SetCurrentItemIndexAndDraw(0); // select new item

            }

        else  // not complete, we're still searching

            {

            DisplayWaitingTextL();

            }

        }

    }

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

// CMPXUPnPBrowseDialog::HandlePropertyL

// Handle playback property.

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

void CMPXUPnPBrowseDialog::HandlePropertyL( TMPXPlaybackProperty /*aProperty*/,

                                            TInt /*aValue*/,

                                            TInt /*aError*/)

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::HandlePropertyL()" );

    // empty

    }

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

// CMPXUPnPBrowseDialog::HandleSubPlayerNamesL

// Method is called continously until aComplete=ETrue, signifying that

// it is done and there will be no more callbacks

// Only new items are passed each time.

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

void CMPXUPnPBrowseDialog::HandleSubPlayerNamesL( TUid /*aPlayer*/,

                            const MDesCArray* aSubPlayers,

                            TBool aComplete,

                            TInt aError)

    {

    MPX_FUNC( "CMPXUPnPBrowseDialog::HandleSubPlayerNamesL()" );

    MPX_DEBUG3( "CMPXUPnPBrowseDialog::HandleSubPlayerNamesL(complete %d, error: %d)",

                aComplete, aError );

    if ( aError == KErrNone )

        {

        DisplaySubPlayersNamesL(aSubPlayers, aComplete);

        }

    else

        {

        if ( ( aError == KErrServerTerminated ) ||

             ( aError == KErrCouldNotConnect ) ||

             ( aError == KErrWlanNetworkNotFound ))

            {

            // defined in errorres.rsg

            DisplayErrorNoteL( R_ERRE_GE_WLAN_WLAN_NETWORK_LOST );

            }

        // No error note specified, we can't get list of subplayers so

        // we just exit the dialog

        iPopup->CancelPopup();

        }

    }

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

// CMPXUPnPBrowseDialog::HandleMediaL

// Call back of media request

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

void CMPXUPnPBrowseDialog::HandleMediaL( const CMPXMedia& /*aProperties*/,