/*

* 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:  Implementation of setup wizard selection storage

*

*/

// INCLUDE FILES

#include <commdb.h>

#include <WlanCdbCols.h>

#include <wlanmgmtclient.h>

#include <driveinfo.h>

#include "cmsettingsfactory.h"

#include "cmmediaserverfull.h"

#include "cmdriveinfo.h"

#include "cmsettings.h"

#include "cmsselectionstorage.h"

#include "msengine.h"

#include "cmstorerulecontainer.h"

#include "cmfillrulecontainer.h"

#include "cmstorerule.h"

#include "cmfillrule.h"

#include "msconstants.h"

#include "msdebug.h"

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

// CMSSelectionStorage::NewL

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

//

CMSSelectionStorage* CMSSelectionStorage::NewL(

                            CMSEngine& aMSEngine,

                            RPointerArray<CCmMediaServerFull>& aServers,

                            RFs& aFs )

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::NewL"));

    CMSSelectionStorage* self = CMSSelectionStorage::NewLC( aMSEngine,

                                                            aServers,

                                                            aFs );

    CleanupStack::Pop(self);

    return self;

    }

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

// CMSSelectionStorage::NewLC

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

//

CMSSelectionStorage* CMSSelectionStorage::NewLC(

                            CMSEngine& aMSEngine,

                            RPointerArray<CCmMediaServerFull>& aServers,

                            RFs& aFs )

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::NewLC"));

    CMSSelectionStorage* self = new (ELeave) CMSSelectionStorage( aMSEngine,

                                                                  aServers,

                                                                  aFs );

    CleanupStack::PushL(self);

    self->ConstructL(  );

    return self;

    }

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

// CMSSelectionStorage::CMSSelectionStorage

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

//

CMSSelectionStorage::CMSSelectionStorage(

                            CMSEngine& aMSEngine,

                            RPointerArray<CCmMediaServerFull>& aServers,

                            RFs& aFs ) :

    iMSEngine( aMSEngine ), iServers( aServers ), iFs( aFs )

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::CMSSelectionStorage"));

    // remove fill & store usage flag from every server

    for ( TInt i = 0; i < iServers.Count(); i++ )

        {

        CCmMediaServerFull* server = iServers[i];

        server->SetStoreUsage( EFalse );

        server->SetStoreUsage( EFalse );

        server->SetIsActive( EFalse );

        }

    }

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

// CMSSelectionStorage::ConstructL

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

//

void CMSSelectionStorage::ConstructL()

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::ConstructL"));

    iStoreRules = iMSEngine.StoreRulesL();

    iFillRules = iMSEngine.FillRulesL();

    iServiceState = ETrue; // default: manual sync   

    }

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

// CMSSelectionStorage::~CMSSelectionStorage

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

//

CMSSelectionStorage::~CMSSelectionStorage()

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::~CMSSelectionStorage"));

    delete iSelectedFillLists;

    delete iSelectedStoreLists;

    delete iStoreRules;

    delete iFillRules;

    }

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

// CMSSelectionStorage::StoreMSSettingsL

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

//

void CMSSelectionStorage::StoreMSSettingsL()

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::StoreMSSettingsL begins"));

    // Set store rules

    iMSEngine.SetStoreRulesL( iStoreRules );

    // Set fill rules

    iMSEngine.SetFillRulesL( iFillRules );

    // Set syncrhronization state

    // if ETrue -> MANUAL mode

    // if EFalse -> AUTOMATIC mode

    if( iServiceState )

        {

        iMSEngine.SetServiceState( ECmServiceContentManager,

                                   ECmServiceStateDisabled );

        }

    else

        {

        iMSEngine.SetServiceState( ECmServiceContentManager,

                                   ECmServiceStateAutomatic );

        // Set wlan scanning on if AUTOMATIC mode

        SetWlanScanL();

        }

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::StoreMSSettingsL ends"));

    }

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

// CMSSelectionStorage::SetWlanScanL

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

//

void CMSSelectionStorage::SetWlanScanL()

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::SetWlanScanL"));

    // open commsdb

    CCommsDatabase* commsDb = CCommsDatabase::NewL();

    CleanupStack::PushL( commsDb );

#ifndef __WINS__

    // open wlan table

    CCommsDbTableView* view = commsDb->OpenViewMatchingUintLC

        (

        TPtrC( WLAN_DEVICE_SETTINGS ),

        TPtrC( WLAN_DEVICE_SETTINGS_TYPE ), KWlanUserSettings

        );

    User::LeaveIfError( view->GotoFirstRecord() );

    User::LeaveIfError( view->UpdateRecord() );

    // set scan interval

    view->WriteUintL( TPtrC( WLAN_BG_SCAN_INTERVAL ), 

                      KWlanScanNetworkInterval60 );

    User::LeaveIfError( view->PutRecordChanges() );

    CleanupStack::PopAndDestroy( view );

#endif

    CleanupStack::PopAndDestroy( commsDb );

#ifndef __WINS__

    CWlanMgmtClient* wlanMgmtClient = CWlanMgmtClient::NewL();

    CleanupStack::PushL( wlanMgmtClient );

    // notify about changes

    wlanMgmtClient->NotifyChangedSettings();

    CleanupStack::PopAndDestroy( wlanMgmtClient );

 #endif

    }

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

// CMSSelectionStorage::SetServersForFillRulesL

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

//

void CMSSelectionStorage::SetServersForFillRulesL( 

                                CArrayFix<TInt>& aSelectedIndexes)

    {

    LOG(_L("[MSAppWizard]\t CMSSelectionStorage::SetServersForFillRulesL "));

    // set server activity anyway

    for ( TInt idx = 0; idx < aSelectedIndexes.Count(); idx++ )

        {

        CCmMediaServerFull* server = iServers[aSelectedIndexes.At(idx)];

        server->SetFillUsage( ETrue );

        server->SetIsActive( ETrue );

        }

    // Get fill list count

    TInt fillrulecount = iFillRules->FillRuleCount();

    // remove all servers from store lists and set unselected

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

        {

        CCmFillRule* rule = iFillRules->FillRule( index );

        // remove list selection

        rule->SetSelected( ECmUnSelected );

        // remove servers

        RemoveServersFromFillRuleL( rule );

        }

    // set selected servers for selected lists

    for( TInt i=0; i<iSelectedFillLists->Count(); i++ )

        {

        TInt index = (*iSelectedFillLists)[i];

        CCmFillRule* rule = iFillRules->FillRule(index);

        rule->SetSelected( ECmSelected );

        SetServersForFillRuleL( rule, aSelectedIndexes );

        }

    }

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

// CMSSelectionStorage::SetServersForFillRuleL

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

//

void CMSSelectionStorage::SetServersForFillRuleL( CCmFillRule* aRule,

                                        CArrayFix<TInt>& aSelectedIndexes )

    {

    LOG(_L("[MSAppWizard]\t SetServersForFillRuleL"));

    TInt ruleServerCount = aRule->MediaServerCount();

    for ( TInt iy = 0; iy < aSelectedIndexes.Count(); iy++ )

        {

        CCmMediaServerFull* server = iServers[aSelectedIndexes.At(iy)];

        TPtrC8 serverUDN = server->MediaServer();

        aRule->AddMediaServerL( serverUDN );        

        server->SetIsActive( KServerActive );

        }    

    }

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

// CMSSelectionStorage::SetServersForStoreRulesL

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

//

void CMSSelectionStorage::SetServersForStoreRulesL(

                                CArrayFix<TInt>& aSelectedIndexes,

                                RPointerArray<CCmMediaServerFull>& aServers )

    {

    // set server activity anyway

    for ( TInt idx = 0; idx < aSelectedIndexes.Count(); idx++ )

        {

        CCmMediaServerFull* server = aServers[aSelectedIndexes.At(idx)];

        server->SetStoreUsage( ETrue );

        server->SetIsActive( ETrue );

        }

    // remove all servers from store lists and set unselected

    for ( TInt index = 0; index < iStoreRules->StoreRuleCount(); index++ )

        {

        CCmStoreRule* rule = iStoreRules->StoreRule( index );

        // remove list selection

        rule->SetSelected( ECmUnSelected );

        RemoveServersFromStoreRuleL( rule );

        }       

    // set selected servers for selected lists

    for ( TInt i = 0; i < iSelectedStoreLists->Count(); i++ )

        {

        TInt selectionValue = iSelectedStoreLists->At( i );

        CCmStoreRule* rule = iStoreRules->StoreRule( selectionValue );

        rule->SetSelected( ECmSelected );

        //...and set selected servers to list

        SetServersForStoreRuleL( rule, aSelectedIndexes, aServers );

        }    

    }

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

// CMSSelectionStorage::SetServersForStoreRuleL

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

//

void CMSSelectionStorage::SetServersForStoreRuleL(

                                CCmStoreRule* aRule,

                                CArrayFix<TInt>& aSelectedIndexes,

                                RPointerArray<CCmMediaServerFull>& aServers )

    {

    LOG(_L("[MSAppWizard]\t SetServersForStoreRuleL"));            

    for ( TInt iy = 0; iy < aSelectedIndexes.Count(); iy++ )

        {

        CCmMediaServerFull* server = aServers[aSelectedIndexes.At(iy)];

        TPtrC8 serverUDN = server->MediaServer();

        aRule->AddMediaServerL( serverUDN );

        server->SetIsActive( KServerActive );

        }

    }

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

// CMSSelectionStorage::RemoveServersFromFillRuleL

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

//

void CMSSelectionStorage::RemoveServersFromFillRuleL( CCmFillRule* aRule )

    {

    //Remove old servers from the rule

    LOG(_L("[MSAppWizard]\t RemoveServersFromFillRuleL"));

    TInt ruleServerCount = aRule->MediaServerCount();

    for ( TInt index = ruleServerCount-1; index >= 0; index-- )

        {

        const TDesC8& ruleServerUDN = aRule->MediaServerL( index );

        aRule->DeleteMediaServer( ruleServerUDN );

        }

    }

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

// CMSSelectionStorage::RemoveServersFromStoreRuleL

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

//

void CMSSelectionStorage::RemoveServersFromStoreRuleL( CCmStoreRule* aRule )

    {

    //Remove old servers from the rule

    LOG(_L("[MSAppWizard]\t RemoveServersFromStoreRuleL"));

    TInt ruleServerCount = aRule->MediaServerCount();

    for ( TInt index = ruleServerCount-1; index >= 0; index-- )

        {

        const TDesC8& ruleServerUDN = aRule->MediaServerL( index );

        aRule->DeleteMediaServer( ruleServerUDN );

        }

    }

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

// CMSSelectionStorage::SetStoreListSelections

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

//

void CMSSelectionStorage::SetStoreListSelections( CArrayFix<TInt>& aSelections )

    {

    if ( iSelectedStoreLists )

        {

        delete iSelectedStoreLists;

        iSelectedStoreLists = NULL;

        }

    iSelectedStoreLists = &aSelections;

    }

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

// CMSSelectionStorage::ClearStoreListSelections

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

//

void CMSSelectionStorage::ClearStoreListSelections()

    {

    iSelectedStoreLists->Reset();

    }

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

// CMSSelectionStorage::SetFillListSelections

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

//

void CMSSelectionStorage::SetFillListSelections(

                                    CArrayFix<TInt>& aSelections )

    {

    if ( iSelectedFillLists )

        {

        delete iSelectedFillLists;

        iSelectedFillLists = NULL;

        }

    iSelectedFillLists = &aSelections;

    }

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

// CMSSelectionStorage::SetAutoManualSelection

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

//

void CMSSelectionStorage::SetAutoManualSelection( TBool aSelection )

    {

    iServiceState = aSelection;

    }

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

// CMSSelectionStorage::AutoManualSelection

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

//

TBool CMSSelectionStorage::AutoManualSelection()

    {

    return iServiceState;

    }

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

// CMSSelectionStorage::SetDriveInformationL

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

//

void CMSSelectionStorage::SetDriveInformationL()

    {

    LOG(_L("[MSAppWizard]\t SetDriveInformationL"));

    MCmSettings* settings = CCmSettingsFactory::NewCmSettingsEngineLC();

    RPointerArray<CCmDriveInfo> driveArray;

    CleanupClosePushL( driveArray );

    settings->DriveListL( iFs, driveArray );

    TInt64 quota(0);

    for ( TInt i = 0; i < driveArray.Count(); i++ )

        {        

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

            {

            // mmc

            quota = ( driveArray[i]->DriveSize() * KMMCDefaultQuota ) / 100;

            LOG(_L("[MSAppWizard]\t CMSSelectionStorage::\

            SetDriveInformationL memory card quota set"));

            }

        else

            {

            // internal hd

            quota = ( driveArray[i]->DriveSize() * KHDDefaultQuota ) / 100;

            LOG(_L("[MSAppWizard]\t CMSSelectionStorage::\

            SetDriveInformationL mass memory quota set"));                      

            }

        // set quota

        driveArray[i]->SetDriveQuota( quota );

        }

    iMSEngine.SetDrivesL( driveArray );

    driveArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &driveArray );

	settings->Close();

    CleanupStack::Pop(); // settings

    }

// End of File