/*

* Copyright (c) 2005-2007 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:      File sharing list implementation for File sharing view

*

*/

// INCLUDE FILES

// system

#include <aknlists.h>

#include <aknPopup.h>

#include <StringLoader.h>

#include <upnpsharingui.rsg>

#include <aknnotewrappers.h>

#include <AknProgressDialog.h>

#include <AknWaitDialog.h>

// internal upnpfw interfaces

#include "upnpsettingsengine.h"

#include "upnpfilesharingengine.h"

#include "cupnpappwizard.h"

#include "upnpcontentserverclient.h" //TUpnpProgressInfo

// this component

#include "upnpsharingui.hrh"

#include "upnpappfilesharinglist.h"

_LIT( KComponentLogfile, "upnpsharingui.txt");

#include "upnplog.h"

// CONSTANTS

_LIT( KCDrive,  "C" );

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

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

// CUPnPAppFileSharingList::CUPnPAppFileSharingList

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

// might leave.

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

//

CUPnPAppFileSharingList::CUPnPAppFileSharingList()

    {

    __LOG("CUPnPAppFileSharingList::CUPnPAppFileSharingList");

    }

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

// CUPnPAppFileSharingList::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUPnPAppFileSharingList::ConstructL(

                                CUPnPFileSharingEngine* aFileSharingEngine)

    {

    __LOG("CUPnPAppFileSharingList::ConstructL");

    iFileSharingEngine = aFileSharingEngine;

    User::LeaveIfNull( iFileSharingEngine );

    iVisibility = 0;

    if ( iFileSharingEngine->SharingStateL() )

        {

        iVisibility = 1;

        }

    }

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

// CUPnPAppFileSharingList::NewL

// Two-phased constructor.

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

//

CUPnPAppFileSharingList* CUPnPAppFileSharingList::NewL(

    CUPnPFileSharingEngine* aFileSharingEngine )

    {

    __LOG("CUPnPAppFileSharingList::NewL");

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

    CleanupStack::PushL(self);

    self->ConstructL( aFileSharingEngine );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPAppFileSharingList::~CUPnPAppFileSharingList

// Destructor

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

//

CUPnPAppFileSharingList::~CUPnPAppFileSharingList()

    {

    __LOG("CUPnPAppFileSharingList::~CUPnPAppFileSharingList");

    // This will kill the possible wait note

    iStartingSharing = EPhaseCompleted;

    delete iWizard;

    iWizard = NULL;

    }

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

// CUPnPAppFileSharingList::CreateSettingItemL

// Creates list items

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

//

CAknSettingItem* CUPnPAppFileSharingList::CreateSettingItemL(TInt aIdentifier)

    {

    __LOG("CUPnPAppFileSharingList::CreateSettingItemL");

    CAknSettingItem* settingItem = NULL;

    switch (aIdentifier)

        {

        case ESharingUiSettingItemVisibility:

            {

            settingItem =

                new (ELeave) CAknBinaryPopupSettingItem(aIdentifier,

                                                        iVisibility);

            break;

            }

        case ESharingUiSettingItemVisual:

            {

            settingItem = new (ELeave) CAknTextSettingItem(aIdentifier,

                                                           iVisualAlbums);

            break;

            }

        case ESharingUiSettingItemMusic:

            {

            settingItem = new (ELeave) CAknTextSettingItem(aIdentifier,

                                                           iPlayLists);

            break;

            }

        default:

            {

            __LOG("CUPnPAppFileSharingList::CreateSettingItemL \

Unknown setting item!");

            }

        }

    return settingItem;

    }

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

// CUPnPAppFileSharingList::EditItemL

// Called when setting list item is modified

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

//

void  CUPnPAppFileSharingList::EditItemL (TInt aIndex, 

                                          TBool /*aCalledFromMenu*/)

    {

    __LOG("CUPnPAppFileSharingList::EditItemL");

    LoadDataFromEngineL();

    switch ( aIndex )

        {

        case ESharingUiSettingItemVisibility:

            {

            if ( !iVisibility )

                {

                if ( iIapId != KErrNotFound )

                    {

                    ShowWaitNoteL();

                    }

                else

                    {

                    iWizardRun = ETrue;

                    MUPnPFileSharingEngineObserver* observer = 

                                    iFileSharingEngine->Observer();

                    delete iWizard;

                    iWizard = NULL;

                    iWizard = CUPnPAppWizard::NewL( 

                        KNullDesC, iFileSharingEngine );

                    iWizard->StartL();

                    iFileSharingEngine->SetObserver(observer);

                    iFileSharingEngine->RequestSharingProgressL();

                    LoadDataFromEngineL();

                    }

                }

            else

                {

                ShowWaitNoteL();

                }

            }

            break;

        default:

            {

            __LOG("CUPnPAppFileSharingList::EditItemL No such item!");

            }

        }

    //load settings to screen

    CAknSettingItemList::LoadSettingsL();

    }

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

// CUPnPAppFileSharingList::LoadDataFromEngineL

// Loads data from Central Repository to member variables

// (other items were commented in a header).

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

//

void  CUPnPAppFileSharingList::LoadDataFromEngineL()

    {

    __LOG("CUPnPAppFileSharingList::LoadDataFromEngineL");

    CUPnPSettingsEngine* settingsEngine = CUPnPSettingsEngine::NewL();

    CleanupStack::PushL( settingsEngine );

    // Read file sharing state

    iVisibility = 0;

    if ( iFileSharingEngine->SharingStateL() )

        {

        iVisibility = 1;

        }

    // Read iap id

    settingsEngine->GetAccessPoint( iIapId );

    //load settings to screen

    CAknSettingItemList::LoadSettingsL ();

    CleanupStack::PopAndDestroy( settingsEngine );

    }

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

// CUPnPAppFileSharingList::HandleSharingStatus

// Function informs when file sharing was enabled or disabled

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

//

void CUPnPAppFileSharingList::HandleSharingStatus( 

        CUPnPFileSharingEngine& /*aEngine*/, 

        TInt aError, 

        TBool aPhase )

    {

    __LOG("CUPnPAppFileSharingList::HandleSharingStatus begin");

    if ( aPhase )

        {

        __LOG("start sharing");

        if ( aError )

            {

            // change state back to off

            iVisibility = EFalse;

            // If there domtree wasn't able to be written due to disk full

            // situation, send leave to kernel to inform user

            if( aError == KErrDiskFull ||

                aError == KErrNoMemory ||

                aError == KErrInUse )

                {

                // stop the wait note

                iStartingSharing = EPhaseCompleted;

                //show some critical errors using

                //default symbian error notes

                CActiveScheduler::Current()->Error( aError );

                }

            else

                {

                // show error note

                TRAP_IGNORE(

                    HBufC* errorNote = StringLoader::LoadLC(

                        R_SETTINGS_START_SHARING_ERROR_TEXT);

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

                    note->ExecuteLD(*errorNote);

                    CleanupStack::PopAndDestroy() ); //errorNote

                }

            }

        else

            {

            // change secondary text

            iVisibility = ETrue;

            }

        }

    else

        {

        __LOG("stop sharing");

        // If the media server lost, aError will be KErrGeneral or

        // KErrServerTerminated.

        // If there were other errors, stop sharing fails and visibility 

        // will remain true.

        if ( !aError || KErrGeneral == aError || 

                KErrServerTerminated == aError )

            {

            iVisibility = EFalse;

            }

        // Note user not enough memory to change the phone state.

        if ( KErrDiskFull == aError ||

             KErrNoMemory == aError ||

             KErrInUse == aError )

            {

            __LOG1( "Not enough memory to change the \

                    phone state error:%d ", aError  );

            //There is nothing to do if leaves

            TRAP_IGNORE(

                HBufC* errorNote = StringLoader::LoadLC(

                    R_SETTINGS_START_SHARING_PHONE_ERROR_TEXT, KCDrive );

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

                note->ExecuteLD( *errorNote );

                CleanupStack::PopAndDestroy( errorNote ) );

            }  

        TRAP_IGNORE(

            CAknSettingItemList::EditItemL(

                ESharingUiSettingItemVisibility, EFalse ) );

        }

    iStartingSharing = EPhaseCompleted;

    // Update UI

    TRAP_IGNORE( CAknSettingItemList::LoadSettingsL() );

    DrawDeferred();

    __LOG("CUPnPAppFileSharingList::HandleSharingStatus end");

    }

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

// CUPnPAppFileSharingList::HandleSharingConnectionLost

// Callback to inform if connection has been lost

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

//

void CUPnPAppFileSharingList::HandleSharingConnectionLost( 

        CUPnPFileSharingEngine& /*aEngine*/ )

    {

    __LOG("CUPnPAppFileSharingList::HandleSharingConnectionLost begin");

    iVisibility = EFalse;

    TRAPD( err,

        CAknSettingItemList::EditItemL (

            ESharingUiSettingItemVisibility, EFalse);

        LoadSettingsL();

        );

    DrawDeferred();

    if ( err != KErrNone )

        {

        //show some critical errors using

        //default symbian error notes

        CActiveScheduler::Current()->Error( err );

        }

    __LOG("CUPnPAppFileSharingList::HandleSharingConnectionLost end");

    }

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

// CUPnPAppFileSharingList::HandleResourceChange

// From CAknDialog

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

//

void CUPnPAppFileSharingList::HandleResourceChange( TInt aType )

    {

    __LOG("CUPnPAppFileSharingList::HandleResourceChange");

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        TRect mainPaneRect;

        AknLayoutUtils::LayoutMetricsRect(

            AknLayoutUtils::EMainPane, mainPaneRect );

        TAknLayoutRect layoutRect;

        layoutRect.LayoutRect(

            TRect( TPoint( 0, 0 ), mainPaneRect.Size() ),

            AKN_LAYOUT_WINDOW_list_gen_pane( 0 ) );

        ListBox()->SetRect( layoutRect.Rect() );

        }

    // Base call

    CAknSettingItemList::HandleResourceChange( aType );

    }

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

// CUPnPAppFileSharingList::SetFilesharingTextsL

// Update the secondary texts in the dialog

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

//

void CUPnPAppFileSharingList::SetFilesharingTextsL( 

    const RArray<TUpnpProgressInfo>& aProgressInfo )

    {

    __LOG( "[CUPnPAppFileSharingList]\t SetFilesharingTextsL begin" );

    for ( TInt i(0); i < aProgressInfo.Count(); i++ )

        {

        if ( aProgressInfo[ i ].iProgressKind == EImageAndVideo )

            {

            if ( aProgressInfo[ i ].iProgressType == 

                 TUpnpProgressInfo::EVisualStatus )

                {

                SetDefaultSecondaryTextsL( EImageAndVideo, 

                                           aProgressInfo[ i ].iProgress );

                }

            else

                {

                SetProgressSecondaryTextsL( EImageAndVideo, 

                                            aProgressInfo[ i ].iProgress );

                }

            }

        else

            {

            if ( aProgressInfo[ i ].iProgressType == 

                 TUpnpProgressInfo::EVisualStatus )

                {

                SetDefaultSecondaryTextsL( EPlaylist, 

                                           aProgressInfo[ i ].iProgress );

                }

            else

                {

                SetProgressSecondaryTextsL( EPlaylist, 

                                            aProgressInfo[ i ].iProgress );

                }

            }

        }

    if( ListBox() && ListBox()->BottomItemIndex() > 1 )

        {

        CAknSettingItemList::LoadSettingsL();

        DrawDeferred();

        }

    __LOG( "[CUPnPAppFileSharingList]\t SetFilesharingTextsL end" );

    }

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

// CUPnPAppFileSharingList::SetDefaultSecondaryTextsL

// Update the secondary texts in the dialog

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

//

void CUPnPAppFileSharingList::SetDefaultSecondaryTextsL( 

    const TInt& aMediaType, 

    const TInt& aState )

    {

    __LOG( "[CUPnPAppFileSharingList]\t \

SetDefaultSecondaryTextsL begin" );

    HBufC* secondaryText = NULL;

    switch ( aMediaType )

        {

    case EImageAndVideo :

        {

        if ( aState == EShareAll)

            {

            secondaryText = StringLoader::LoadLC(

                R_VISUAL_ALBUMS_SHARE_MANY_TEXT);

            }

        else if ( aState == EShareNone)

            {

            secondaryText = StringLoader::LoadLC(

                R_VISUAL_ALBUMS_SHARE_NOTHING_TEXT);

            }

        else // there were shared files

            {

            secondaryText = StringLoader::LoadLC(

                R_VISUAL_ALBUMS_SHARE_ONE_TEXT);

            }

        iVisualAlbums.Copy( *secondaryText );

        }

        break;

    case EPlaylist :

        {

        if ( aState == EShareAll)

            {

            secondaryText = StringLoader::LoadLC(R_MUSIC_SHARE_MANY_TEXT);

            }

        else if ( aState == EShareNone)

            {

            secondaryText = StringLoader::LoadLC(

                R_MUSIC_SHARE_NOTHING_TEXT);

            }

        else // there were shared files

            {

            secondaryText = StringLoader::LoadLC(R_MUSIC_SHARE_ONE_TEXT);

            }

        iPlayLists.Copy( *secondaryText );

        }

        break;

    default:

        break;

        }

    CleanupStack::PopAndDestroy( secondaryText );

    __LOG( "[CUPnPAppFileSharingList]\t SetDefaultSecondaryTextsL end" );

    }

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

// CUPnPAppFileSharingList::SetProgressSecondaryTextsL

// Update the secondary texts in the dialog

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

//

void CUPnPAppFileSharingList::SetProgressSecondaryTextsL( 

    const TInt& aMediaType, 

    const TInt& aProgress )

    {

    __LOG( "[CUPnPAppFileSharingList]\t \

SetProgressSecondaryTextsL begin" );

    HBufC* secondaryText = StringLoader::LoadLC(

            R_SHARINGUI_SECONDARY_IN_PROGRESS, aProgress );

    switch ( aMediaType )