/*

* 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 "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:  CMSSettingItemList class implementation

*

*/

#include <msgspluginsrc.rsg>

#include <commdb.h> // for RProperty

#include <StringLoader.h> // for StringLoader

#include <centralrepository.h> // for profile

#include <ProfileEngineSDKCRKeys.h> // for profile

#include <driveinfo.h>

#include "cmsettingsfactory.h"

#include "cmcommonutils.h"

#include "cmsettings.h"

#include "cmdriveinfo.h"

#include "mserv.hlp.hrh"

#include "msengine.h"

#include "mssettingitemlist.h"

#include "mssettingitemmemory.h" // mmc name

#include "mssettingitemdevices.h" // source devices

#include "mssettingsview.h"

#include "msconstants.h"

#include "cmmediaserverfull.h"

#include "msdebug.h"

// CONSTANTS

const TInt KOfflineProfile = 5;

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

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

// CMSSettingItemList::NewL()

// Two phase constructor.

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

//

CMSSettingItemList* CMSSettingItemList::NewL( TInt aResourceId,

                                              CMSSettingsView& aView )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::NewL"));

    CMSSettingItemList* self = CMSSettingItemList::NewLC( aResourceId, 

	                                                      aView );

	CleanupStack::Pop( self );

    return self;

    }

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

// CMSSettingItemList::NewLC()

// Two phase constructor.

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

//

CMSSettingItemList* CMSSettingItemList::NewLC( TInt aResourceId,

                                              CMSSettingsView& aView )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::NewLC"));

    CMSSettingItemList* self = new ( ELeave ) CMSSettingItemList(

                                                aView );

    CleanupStack::PushL( self );

    self->ConstructL( aResourceId );

    return self;

    }

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

// CMSSettingItemList::CMSSettingItemList()

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

//

CMSSettingItemList::CMSSettingItemList( CMSSettingsView& aView )

    : iView( aView )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::CMSSettingItemList"));

    }

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

// CMSSettingItemList::~CMSSettingItemList()

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

//

CMSSettingItemList::~CMSSettingItemList()

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::~CMSSettingItemList"));

	if ( iStoredServers ) 

		{

		iStoredServers->ResetAndDestroy();

	    iStoredServers->Close();

	    delete iStoredServers;		

		}

    if ( iMSEngine )

        {

        delete iMSEngine;    

        }    

    }

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

// CMSSettingItemList::ConstructL()

// Second phase constructor.

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

//

void CMSSettingItemList::ConstructL( TInt aResourceId )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::ConstructL"));

    // Create engine

    iMSEngine = CMSEngine::NewL();

    // Set engine observer

    iMSEngine->SetObserver( this );

    // Read memory manager setting

    iMemoryManager =

           iMSEngine->ServiceState( ECmServiceMemoryManager );

    iSync = iMSEngine->ServiceState( ECmServiceContentManager );

    // Get server list

    iStoredServers = iMSEngine->GetMediaServersL();

    CAknSettingItemList::ConstructFromResourceL( aResourceId );

    // sets memory selection setting visibility

    SetMemorySelectionL();

    iListBox = ListBox();

    }

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

// CMSSettingItemList::OpenSelectedListboxItemL

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

//

void CMSSettingItemList::OpenSelectedListboxItemL()

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::OpenSelectedListboxItemL"));

    HandleListBoxEventL( ListBox(), EEventEnterKeyPressed );

    }

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

// CMSSettingItemList::HandleListBoxEventL()

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

//

void CMSSettingItemList::HandleListBoxEventL( CEikListBox *aListBox,

                                              TListBoxEvent aEventType)

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::HandleListBoxEventL"));

    CAknSettingItemList::HandleListBoxEventL( aListBox, aEventType );

    // UI selection is stored to actual settings variable

    StoreSettingsL();

    TInt listBoxItemIndex = iListBox->CurrentItemIndex();

    CAknSettingItemArray* itemArray = SettingItemArray();

    TInt realIndex = itemArray->ItemIndexFromVisibleIndex(

                                                      listBoxItemIndex );

    if ( realIndex == EMSSettingsSync )

        {

        iMSEngine->SetServiceState( ECmServiceContentManager,

                                             iSync );

        // inform plugin about changed setting

        TCmProgressInfo info;

        info.iProcessedItems = 0,

        info.iTotalItems = 0;

        info.iService = ECmServiceNone;

        TCmProgressInfoPckg transferInfoPckg( info );

        RProperty::Set( KCmPropertyCat, KCmProperty,

        transferInfoPckg );

        // we aren't allowed to set wlan scanning in offline mode

        if ( GetCurrentProfileL() != KOfflineProfile )

            {

            // Set wlan scanning parameters

            TInt interval = ( iSync == ECmServiceStateDisabled ?

                    KWlanScanNetworkNever : KWlanScanNetworkInterval60 );

            CmCommonUtils::SetWlanScanL( interval );

            }

        }

    else if ( realIndex == EMSMemoryManager )

        {

        iMSEngine->SetServiceState( ECmServiceMemoryManager,

                                             iMemoryManager );

        }

    else

        {

        LOG(_L("[MediaServant]\t CMSSettingItemList::\

        HandleListBoxEventL no such item"));

        }

    }

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

// CAknSettingItem* CMSSettingItemList::CreateSettingItemL(TInt aIdentifier)

// Takes care of creating actual setting items.

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

//

CAknSettingItem* CMSSettingItemList::CreateSettingItemL( TInt aIdentifier )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::CreateSettingItemL"));

    CAknSettingItem* settingItem = NULL;

    // setting item is created according to aIdentifier

    switch ( aIdentifier )

        {

        case EMSSettingsSync:

            {

            LOG(_L("[MediaServant]\t List Item: EMSSettingsSync"));

            settingItem = new (ELeave ) CAknEnumeratedTextPopupSettingItem(

                                         aIdentifier,

                                         reinterpret_cast<TInt&> (iSync) );

            break;

            }

        case EMSSettingsSourceDevices:

            {

            LOG(_L("[MediaServant]\t List Item: EMSSettingsSourceDevices"));

            settingItem = CMSSettingItemDevices::NewL (

                                            aIdentifier,

                                            iDummyText,

                                            *iMSEngine,

                                            *iStoredServers );

            break;

            }

        case EMSSettingsTargetDevices:

            {

            LOG(_L("[MediaServant]\t List Item: EMSSettingsTargetDevices"));

            settingItem = CMSSettingItemDevices::NewL (

                                            aIdentifier,

                                            iDummyText,

                                            *iMSEngine,

                                            *iStoredServers,

                                            ETrue );

            break;

            }

        case EMSSettingsMemory:

            {

            LOG(_L("[MediaServant]\t List Item: EMSSettingsMMC"));

            settingItem = CMSSettingItemMemory::NewL (

                                            aIdentifier,

                                            iDummyText,

                                            *iMSEngine,                                            

                                            *this );

            break;

            }

        case EMSMemoryManager:

            {

            LOG(_L("[MediaServant]\t List Item: EMSMemoryManager"));

            settingItem = new ( ELeave ) CAknBinaryPopupSettingItem(

                                  aIdentifier,

                                  reinterpret_cast<TBool&> (iMemoryManager) );

            break;

            }

        default:

            {

            LOG(_L("[MediaServant]\t No list item found"));

            break;

            }

        }

    return settingItem;

    }

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

// CMSSettingItemList::EditItemL()

// Called by framework when item is opened

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

//

void  CMSSettingItemList::EditItemL ( TInt aIndex, TBool aCalledFromMenu )

    {

    CAknSettingItemList::EditItemL( aIndex, aCalledFromMenu );

    if ( iListBox->CurrentItemIndex() == EMSSettingsSourceDevices )

        {

        CMSSettingItemDevices* item = static_cast<CMSSettingItemDevices*>

                               (SearchItemById( EMSSettingsSourceDevices ));

        if ( item->SettingAccepted() )

            {

            TCmServerState state( ECmServerStateIdle );

            // List of unselected servers

            RPointerArray<CCmMediaServerFull> unselectedServers;

            iMSEngine->ServerState( state );

            if ( state != ECmServerStateIdle )

                {

                iMSEngine->StopOperation();

                }

            iView.ClearCurrentNaviPaneText();

            iMSEngine->DeleteMetadataL();

            HBufC* naviText = StringLoader::LoadLC(

                                 R_MS_PREPROCESSING_TEXT );

            iView.SetNavigationPaneTextL( *naviText );

            CleanupStack::PopAndDestroy( naviText );

            }

        }

    }

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

// CMSSettingItemList::SearchItemById

// Searches item from the itemarray by given ID

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

//

CAknSettingItem* CMSSettingItemList::

                SearchItemById( const TMSSettingItems aId ) const

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::SearchItemById"));

    CAknSettingItem* item = NULL;

    CAknSettingItemArray* itemArray = SettingItemArray();

    TInt count = itemArray->Count();

    for ( TInt index = 0; index < count; index++ )

        {

        if ( itemArray->At( index )->Identifier() == aId )

            {

            item = itemArray->At( index );

            // end loop

            index = count;

            }

        }

    return item;

    }

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

// CMSSettingItemList::SizeChanged()

// Called by framework when the view size is changed.

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

//

void CMSSettingItemList::SizeChanged()

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::SizeChanged"));

    ListBox()->SetRect( Rect() ); // Set rectangle of listbox.

    }

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

// CMSSettingItemList::HandleResourceChange

// Handles layout change

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

//

void CMSSettingItemList::HandleResourceChange( TInt aType )

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::HandleResourceChange"));

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        SetRect( iView.ClientRect() );

        }

    CCoeControl::HandleResourceChange( aType );

    }

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

// CMSSettingItemList::ReadyL()

// engine observer callback

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

//

#ifdef __DEBUG

void CMSSettingItemList::ReadyL( TCmService aService, TInt aError )

#else

void CMSSettingItemList::ReadyL( TCmService aService, TInt /*aError*/ )

#endif

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::ReadyL"));

#ifdef __DEBUG

    TRACE(Print(_L("[MediaServant]\t CMSSettingItemList::\

    ReadyL error %d"), aError));

#endif

    switch ( aService )

        {

        case ECmServiceDeleteMetadata:

            {

            iMSEngine->ExecuteFillPreProcessingL();

            break;

            }

        case ECmServicePreProcessingFill:

            {

            iView.ClearCurrentNaviPaneText();

            break;

            }

        default:

            {

            // do nothing

            break;

            }

        }

    }

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

// CMSSettingItemList::MSEngine()

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

//

CMSEngine* CMSSettingItemList::MSEngine()

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::MSEngine"));

    return iMSEngine;

    }

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

// CMSMainContainer::GetCurrentProfileL()

// Reads current profile

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

//

TInt CMSSettingItemList::GetCurrentProfileL() const

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::GetCurrentProfileL"));

    TInt profile( 0 );

    CRepository* repository = CRepository::NewLC( KCRUidProfileEngine );

    repository->Get( KProEngActiveProfile, profile );

    CleanupStack::PopAndDestroy( repository );

    return profile;

    }

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

// CMSSettingItemList::SetMemorySelectionL

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

//

void CMSSettingItemList::SetMemorySelectionL()

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::SetMemorySelectionL"));

    TBool memoryCardFound( EFalse );

    RPointerArray<CCmDriveInfo> driveArray;

    CleanupClosePushL( driveArray );

    MCmSettings* settings = CCmSettingsFactory::NewCmSettingsEngineLC();

    // get available drives

    settings->DriveListL( ControlEnv()->FsSession(), driveArray );

	settings->Close();

    CleanupStack::Pop(); // settings

    TInt driveCount = driveArray.Count();

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

        {

        if ( driveArray[i]->DriveType() == DriveInfo::EDriveRemovable )

            {

            memoryCardFound = ETrue;

            i = driveCount; // break loop

            }

        }

    if ( !memoryCardFound )

        {

        CAknSettingItem* item = SearchItemById( EMSSettingsMemory );

        item->SetHidden( ETrue);

        // visibility changed

        HandleChangeInItemArrayOrVisibilityL();

        }

    driveArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &driveArray );

    }

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

// CMSSettingItemList::GetHelpContext

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

//

void CMSSettingItemList::GetHelpContext( TCoeHelpContext& aContext ) const

    {

    LOG(_L("[MediaServant]\t CMSSettingItemList::GetHelpContext"));

    aContext.iMajor = KUidMediaServant;

    aContext.iContext = KMSERV_HLP_SYNC_SETTINGS;

    }

// End of File