/*

* Copyright (c) 2005 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:  Source file for UPnP External device dialog

*                UI Implementation

*

*/

// INCLUDE FILES

// System

#include <aknnavide.h> // CAknNavigationDecorator

#include <barsread.h> // TResourceReader

#include <AknIconArray.h>

#include <eikclbd.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <hlplch.h>

#include <upnpstring.h>

#include <layoutmetadata.cdl.h>

// upnpframework / avcontroller api

#include "upnpavdevice.h"

#include "upnpavcontroller.h"

#include "upnpavbrowsingsession.h"

#include "upnpavdevicelist.h"

// upnpframework / internal api's

#include "upnpcommonutils.h"

// common ui internal

#include "upnpadvfinddialog.h"

#include "upnpcommonui.hrh"

#include "upnpexternaldevicedialog.h"

#include <upnpcommonui.rsg>

#include <upnpcommonui.mbg> //for icons

#include "upnpcommonui.h"

#include "upnpnavipanecontainer.h"

_LIT( KComponentLogfile, "commonui.txt");

#include "upnplog.h"

// CONSTANTS

_LIT( KAknCommonUIMbmFileName, "\\resource\\apps\\upnpcommonui.mbm" );

const TInt KLength = 100;

_LIT(KUPNP_HLP_MAIN_EXTERNAL,"UPNP_HLP_MAIN_EXTERNAL"); 

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

// CUPnPExternalDeviceDialog::CUPnPExternalDeviceDialog

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

// might leave.

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

//

CUPnPExternalDeviceDialog::CUPnPExternalDeviceDialog(

                                        MUPnPAVController& aAVControl,

                                        CUPnPCommonUI& aCommonUI):

                                        iAVControl(aAVControl),

                                        iCommonUI(aCommonUI)

    {

    iPreDeviceObserver = iAVControl.DeviceObserver();

    iAVControl.RemoveDeviceObserver();

    iAVControl.SetDeviceObserver( *this );

    }

// Destructor

CUPnPExternalDeviceDialog::~CUPnPExternalDeviceDialog()

    {

    __LOG( "CUPnPExternalDeviceDialog::~CUPnPExternalDeviceDialog" );

    delete iDeviceArray;

    iAVControl.RemoveDeviceObserver();

    if( iPreDeviceObserver )

        {

        iAVControl.SetDeviceObserver( *iPreDeviceObserver );

        }

    if ( iNaviDecorator && iNaviPaneContainer )

        {

        iNaviPaneContainer->Pop( iNaviDecorator );

        }

    delete iNaviDecorator;

    iNaviDecorator = NULL;

    __LOG( "CUPnPExternalDeviceDialog::~CUPnPExternalDeviceDialog End." );

    }

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

// CUPnPExternalDeviceDialog::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUPnPExternalDeviceDialog::ConstructL( TInt aMenuResource )

    {

    __LOG( "CUPnPExternalDeviceDialog::ConstructL" );

    iDeviceArray = CUpnpAVDeviceList::NewL();

    CAknDialog::ConstructL( aMenuResource );

    __LOG( "CUPnPExternalDeviceDialog::ConstructL End" );

    }

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

// CUPnPExternalDeviceDialog::NewL

// Two-phased constructor.

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

//

CUPnPExternalDeviceDialog* CUPnPExternalDeviceDialog::NewL(

    TInt aMenuResource, 

    MUPnPAVController& aAVControl,

    CUPnPCommonUI& aCommonUI)

    {

    __LOG( "CUPnPExternalDeviceDialog::NewL" );

    CUPnPExternalDeviceDialog* self = 

                        new ( ELeave ) CUPnPExternalDeviceDialog( aAVControl,

                                                                aCommonUI );

    CleanupStack::PushL( self );

    self->ConstructL( aMenuResource );

    CleanupStack::Pop();

    __LOG( "CUPnPExternalDeviceDialog::NewL End" );

    return self;

    }

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

// CUPnPExternalDeviceDialog::PreLayoutDynInitL();

// called by framework before dialog is shown

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

//

void CUPnPExternalDeviceDialog::PreLayoutDynInitL()

    {

    __LOG( "CUPnPExternalDeviceDialog::PreLayoutDynInitL" );

    // Create dialog title text

    CEikStatusPane* statusPane = 

                    ( ( CAknAppUi* )iEikonEnv->EikAppUi() )->StatusPane();    

    iTitlePane = ( CAknTitlePane* )statusPane->ControlL(

                    TUid::Uid( EEikStatusPaneUidTitle ) );

    iTitlePane->SetTextL( *StringLoader::LoadLC(

                                R_UPNPCOMMONUI_EXTERNAL_MEDIA_TITLE ) );

    CleanupStack::PopAndDestroy();

    iListBox = static_cast<CAknSingleGraphicStyleListBox*>

              ( Control( EUPnPExternDevicesListBoxId ) );

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

            CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

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

    CleanupStack::PushL(icons);

    // Mif icons

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath( AknIconUtils::AvkonIconFileName( ) );

    // Folder icon

    TFileName mbmFileName( KAknCommonUIMbmFileName );

    TFileName dllName;

    Dll::FileName( dllName );

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

    mbmFileName.Insert( 0, drive );

    AppendIconToArrayL( icons, skin, 

                        mbmFileName, 

                        KAknsIIDDefault, 

                        EMbmUpnpcommonuiQgn_server_icon, 

                        EMbmUpnpcommonuiQgn_server_icon_mask );

    iListBox->ItemDrawer()->ColumnData()->SetIconArray( icons );

    CleanupStack::Pop( icons );

    // Enable horizontal scrolling

    iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

    DisplayMediaServersL();

    if ( !iDeviceArray->Count() )  

        {

        // show "Waiting devices" text

        iListBox->View()->SetListEmptyTextL(

            *StringLoader::LoadLC( R_UPNPCOMMONUI_EXTERNAL_WAITING_NOTE ) );

        CleanupStack::PopAndDestroy(); 

        }

    else

        {

        CEikButtonGroupContainer* cba = &ButtonGroupContainer();

        cba->SetCommandSetL( R_UPNPCOMMONUI_SOFTKEYS_OPTIONS_BACK__OPEN );

        cba->DrawDeferred();

        }

    __LOG( "CUPnPExternalDeviceDialog::PreLayoutDynInitL End" );    

    }

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

// CUPnPExternalDeviceDialog::PostLayoutDynInitL();

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

//

void CUPnPExternalDeviceDialog::PostLayoutDynInitL()

    {

    iNaviPaneActive = ETrue;

    UpDateAnimationWindowL(iNaviPaneActive);//DateAnimationWindow();

    }

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

// CUPnPExternalDeviceDialog::OkToExitL(TInt aButtonId)

// see upnpexternaldevicedialog.h

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

//

TBool CUPnPExternalDeviceDialog::OkToExitL( TInt aButtonId )

    {

    __LOG( "CUPnPExternalDeviceDialog::OkToExitL" );

    TBool returnValue = EFalse;

    iCommonUI.HandleCommonErrorL( aButtonId, NULL );

    // Translate the button presses into commands for the appui & current

    // view to handle

    switch ( aButtonId )

        {

        case EAknSoftkeyOptions:

            {

            DisplayMenuL(); 

            break;

            }

        case EAknSoftkeyOpen: //fall through

        case EAknSoftkeyOk:

            {

            CTextListBoxModel *model = iListBox->Model();

            if (model->NumberOfItems()) //browse only if list have items

                {

                iNaviPaneActive = EFalse;                

                UpDateAnimationWindowL(iNaviPaneActive);

                TInt ret = ExecuteBrowseL();

                if (ret == EAknCmdExit || 

                    ret == EEikCmdExit ||

                    ret == KErrDisconnected ||

                    ret == KErrSessionClosed

                    )

                    {

                    TryExitL( ret );

                    }

                else

                    {

                    DisplayMediaServersL();

                    iNaviPaneActive = ETrue;

                    UpDateAnimationWindowL(iNaviPaneActive);

                    }

                }

            break;

            }

        case EAknSoftkeyBack: // fall through

        case EUPnPBackCmd: // fall through

        case EAknSoftkeyCancel: // fall through

        case EAknSoftkeyExit: // fall through

        case EAknCmdExit: // fall through

        case EEikCmdExit: // fall through

        case KErrNotReady: // fall through

        case KErrDisconnected:

            {

            if( iTitlePane )

                {

                iTitlePane->SetTextToDefaultL();

                }

            returnValue = ETrue; //back to previous dialog

            break;

            }

        case KErrSessionClosed:

            {

            DisplayMediaServersL();

            iNaviPaneActive = ETrue;

            UpDateAnimationWindowL(iNaviPaneActive);

            break;

            }

        default:

            {

            // ignore

            }

        }

    __LOG( "CUPnPExternalDeviceDialog::OkToExitL End." );

    return returnValue;

    }

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

// CUPnPExternalDevice::DynInitMenuPaneL(TInt aResourceId, 

// CEikMenuPane *aMenuPane)

// called by framework before menu panel is shown

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

void  CUPnPExternalDeviceDialog::DynInitMenuPaneL( TInt aResourceId,

                                                   CEikMenuPane *aMenuPane )

    {

    __LOG( "CUPnPExternalDeviceDialog::DynInitMenuPaneL" );

    if( aResourceId ==  R_UPNPCOMMONUI_EXTERNAL_DEVICE_OPTION_MENU )

        {

        // Hide menu items if empty list

        CTextListBoxModel *model = iListBox->Model();

        if ( !model->NumberOfItems() ) 

            {

            aMenuPane->SetItemDimmed( EUPnPOpen, ETrue );

            aMenuPane->SetItemDimmed( EUPnPFind, ETrue );

            }

        // Hide "Find" if the currently focused device does not support it

        TInt selected_item = iListBox->CurrentItemIndex();

        if( selected_item >= 0 &&

            !( *iDeviceArray )[ selected_item ]->SearchCapability() )

            {

            aMenuPane->SetItemDimmed( EUPnPFind, ETrue );

            }

        // Hide "Help" if the help file is not available

        if( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

            {

            aMenuPane->SetItemDimmed( EUPnPHelp, ETrue );

            }

        }

    __LOG( "CUPnPExternalDeviceDialog::DynInitMenuPaneL End" );    

    }

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

// CUPnPExternalDeviceDialog::ProcessCommandL(TInt aCommand)

// called by framework when menu item is selected

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

//

void CUPnPExternalDeviceDialog::ProcessCommandL( TInt aCommand )

    {

    __LOG( "CUPnPExternalDeviceDialog::ProcessCommandL" );

    TInt error = KErrNone;

    HideMenu();

    switch ( aCommand ) 

        {

        case EAknCmdExit:

        case EEikCmdExit:

            {

            TryExitL( aCommand );

            break;

            }

        case EUPnPOpen:

            {

            iNaviPaneActive = EFalse;

            UpDateAnimationWindowL(iNaviPaneActive);

            error = ExecuteBrowseL();

            if ( error == EAknCmdExit ||

                 error == EEikCmdExit ||

                 error == KErrDisconnected ||

                 error == KErrSessionClosed )

                {

                TryExitL( error );

                }

            else 

                {

                DisplayMediaServersL(); 

                iNaviPaneActive = ETrue;

                UpDateAnimationWindowL(iNaviPaneActive); 

                }

            break;

            }

        case EUPnPFind:

            {

            iNaviPaneActive = EFalse;

            UpDateAnimationWindowL(iNaviPaneActive);  

            error = ExecuteFindL();

            if ( error == EAknCmdExit ||

                 error == EEikCmdExit ||

                 error == KErrDisconnected || 

                 error == KErrNotReady || 

                 error == KErrSessionClosed )

                {

                TryExitL( error );

                }

            else

                {

                iNaviPaneActive = ETrue;

                UpDateAnimationWindowL(iNaviPaneActive);

                }

            break;

            }

        case EUPnPHelp:

            {

            iNaviPaneActive = EFalse;

            UpDateAnimationWindowL(iNaviPaneActive);

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),

            iEikonEnv->EikAppUi()->AppHelpContextL() );

            iNaviPaneActive = ETrue;

            UpDateAnimationWindowL(iNaviPaneActive);

            break;

            }

        default:

            break;

        }

    __LOG( "CUPnPExternalDeviceDialog::ProcessCommandL End" );    

    }

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

// CUPnPExternalDeviceDialog::UPnPDeviceDiscovered

// Returns discovered device from UPnP AV control point.

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

//

void CUPnPExternalDeviceDialog::UPnPDeviceDiscovered(

                                        const CUpnpAVDevice& aDevice )

    {

    __LOG( "CUPnPExternalDeviceDialog::UPnPDeviceDiscovered" );

    TInt error = KErrNone;

    TRAP( error, UPnPDeviceDiscoveredL( aDevice ) );

    __LOG1( "CUPnPExternalDeviceDialog::UPnPDeviceDiscovered %d", error);

    }

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

// CUPnPExternalDeviceDialog::UPnPDeviceDiscoveredL

// Returns discovered device from UPnP AV control point.

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

//

void CUPnPExternalDeviceDialog::UPnPDeviceDiscoveredL(

                                        const CUpnpAVDevice& aDevice )

    {

    __LOG( "CUPnPExternalDeviceDialog::UPnPDeviceDiscovered" );

    // Display only Media servers

    if( aDevice.DeviceType() == CUpnpAVDevice::EMediaServer )

        {

        CUpnpAVDevice* tempDevice = CUpnpAVDevice::NewL( aDevice ) ;

        CleanupStack::PushL( tempDevice );

        iDeviceArray->AppendDeviceL( *tempDevice );

        CleanupStack::Pop( tempDevice ); 

        // Get device friendly name and replace illegal characters.

        HBufC8* tmpfriendlyname = 

            UPnPCommonUtils::ReplaceIllegalFilenameCharactersL( 

            ( ( CUpnpAVDevice* )tempDevice )->FriendlyName() );

        CleanupStack::PushL( tmpfriendlyname );

        TPtrC8 friendlyname = *tmpfriendlyname;

        CTextListBoxModel* model = iListBox->Model();

        MDesCArray* textArray = model->ItemTextArray();

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

        TBuf<256> item;

        HBufC *tmpbuf = UpnpString::ToUnicodeL( friendlyname.Left( KLength ) );

        CleanupStack::PushL( tmpbuf ); 

        item.Format( _L( "%d\t%S\t\t" ),0, tmpbuf ); 

        CleanupStack::PopAndDestroy( tmpbuf ); 

        CleanupStack::PopAndDestroy( tmpfriendlyname );

        listBoxItems->AppendL( item );

        iListBox->HandleItemAdditionL(); // Update listbox

        iListBox->ActivateL();

        iListBox->DrawDeferred();

        //update menu pane

        CEikButtonGroupContainer* cba = &ButtonGroupContainer();

        cba->SetCommandSetL( R_UPNPCOMMONUI_SOFTKEYS_OPTIONS_BACK__OPEN );

        cba->DrawDeferred();

        }

    __LOG( "CUPnPExternalDeviceDialog::UPnPDeviceDiscovered End" );

    }

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

// CUPnPExternalDeviceDialog::UPnPDeviceDisappeared

// Returns disappeared device from UPnP AV control point.

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

//

void CUPnPExternalDeviceDialog::UPnPDeviceDisappeared(

                                        const CUpnpAVDevice& aDevice )

    {

    __LOG( "CUPnPExternalDeviceDialog::UPnPDeviceDisappeared" );

    TRAP_IGNORE( UPnPDeviceDisappearedL( aDevice ) );

    }

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

// CUPnPExternalDeviceDialog::UPnPDeviceDisappearedL

// Returns disappeared device from UPnP AV control point.

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

//

void CUPnPExternalDeviceDialog::UPnPDeviceDisappearedL(

                                               const CUpnpAVDevice& aDevice )

    {

    __LOG( "CUPnPExternalDeviceDialog::UPnPDeviceDissapearedL" );

    CTextListBoxModel* model = iListBox->Model();

    TInt currentItem = iListBox->CurrentItemIndex();

    MDesCArray* textArray = model->ItemTextArray();

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

    TInt i = 0;

    TPtrC8 ptr(aDevice.Uuid());

    while( i < iDeviceArray->Count() &&

        ptr.Compare( ( *iDeviceArray)[ i ]->Uuid() ) )

        {

        i++;

        }

    if ( i < iDeviceArray->Count() )

        {

        iDeviceArray->RemoveAndDestroy( i );

        listBoxItems->Delete( i,1 );

        AknListBoxUtils::HandleItemRemovalAndPositionHighlightL(

            iListBox, currentItem, ETrue );

        iListBox->DrawDeferred();

        }

    if ( !iDeviceArray->Count() )

        {