/*

* Copyright (c) 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:  CMediaServantAppUi class implementation

*

*/

#include <StringLoader.h>

#include <mediaservant.rsg>

#include <f32file.h>

#include <driveinfo.h>

#include "cmsettingsfactory.h"

#include "cmsettings.h"

#include "cmdriveinfo.h"

#include "msappui.h"

#include "msstorelistcontroller.h"

#include "msmainview.h"

#include "msfillview.h"

#include "msfillruleeditview.h"

#include "msstorelistview.h"

#include "msstoresettingsview.h"

#include "msbrowseview.h"

#include "msfillbrowseview.h"

#include "msconstants.h"

#include "msengine.h"

#include "msparameteragent.h"

#include "cmsappwizard.h"

#include "msgsinterface.h"

#include "msgspluginuids.h"

#include "msdebug.h"

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

// CMSAppUi::ConstructL()

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

//

void CMSAppUi::ConstructL()

    {

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

#ifndef __SERIES60_31__

    BaseConstructL( EAknEnableSkin | EAknEnableMSK );

#else

    BaseConstructL( EAknEnableSkin );

#endif

    // Create engine

    iMSEngine = CMSEngine::NewL();

    // Create parameter agent for message passing between views

    iParameterAgent = new ( ELeave ) CMSParameterAgent();

    // Create fill list controller

    iFillRuleController = CMSFillRuleController::NewL( *iMSEngine );

    // Create store list controller

    iStoreListController = CMSStoreListController::NewL( *iMSEngine );

    LoadSettingsPluginL(); // loads gs plugin

    // main view is created

    CMSMainView* mainView = new ( ELeave )CMSMainView( *this );

    CleanupStack::PushL( mainView );

    mainView->ConstructL();

    AddViewL( mainView );           // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( mainView);

    CMSFillView* fillView = new ( ELeave ) CMSFillView( *this );

    CleanupStack::PushL( fillView );

    fillView->ConstructL();

    AddViewL( fillView );           // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( fillView );

    CMSFillRuleEditView* ruleEditView = new ( ELeave )

                                            CMSFillRuleEditView( *this );

    CleanupStack::PushL( ruleEditView );

    ruleEditView->ConstructL();

    AddViewL( ruleEditView );       // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( ruleEditView );

    CMSStoreListView* storelistView = new ( ELeave )

                                CMSStoreListView( *this );

    CleanupStack::PushL( storelistView );

    storelistView->ConstructL();

    AddViewL( storelistView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( storelistView);

    CMSStoreSettingsView* storesettingView = new ( ELeave )

                                CMSStoreSettingsView( *this );

    CleanupStack::PushL( storesettingView );

    storesettingView->ConstructL();

    AddViewL( storesettingView );   // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( storesettingView );

    CMSBrowseView* browseView = new ( ELeave )

                                CMSBrowseView( *this );

    CleanupStack::PushL( browseView );

    browseView->ConstructL();

    AddViewL( browseView );   // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( browseView );

    CMSFillBrowseView* fillBrowseView =

                    new ( ELeave ) CMSFillBrowseView( *this );

    CleanupStack::PushL( fillBrowseView );

    fillBrowseView->ConstructL();

    AddViewL( fillBrowseView );   // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( fillBrowseView );

    // default view is now main view

    SetDefaultViewL( *mainView );

    }

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

// CMSAppUi::~CMSAppUi()

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

//

CMSAppUi::~CMSAppUi()

    {

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

    if( iPlugin )

        {

        // Destroy Ecom plugin

        iPlugin->DestroyPlugin();

        }

    delete iMSEngine;

    delete iParameterAgent;

    delete iFillRuleController;

    delete iStoreListController;

    }

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

// CMSAppUi::HandleCommandL(TInt aCommand)

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

//

void CMSAppUi::HandleCommandL(TInt aCommand)

    {

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

    switch ( aCommand )

        {

        case EAknSoftkeyBack:

        // fall trough

        case EEikCmdExit:

            {

            // program is exited

            Exit();

            break;

            }

        default:

            {

            LOG(_L("[MediaServant]\t CMSAppUi::HandleCommandL \

            invalid command"));

            break;

            }

        }

    }

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

// CMSAppUi::ChangeViewL()

//

// Changes active view according to input parameter.

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

//

void CMSAppUi::ChangeViewL(const TUid& aOldView, const TUid& aNewView)

    {

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

    iParameterAgent->SetPreviousViewId( aOldView );

    if ( aOldView.iUid == KMSMainViewId.iUid )

        {

        // store focus index of main view

        iParameterAgent->SetMainViewFocusIndex(

                    static_cast<CMSMainView*> (iView)->FocusIndex());

        }

    else if ( aOldView.iUid == KMSFillViewId.iUid )

        {

        // store focus index of main view

        iParameterAgent->SetFillViewFocusIndex(

                    static_cast<CMSFillView*> (iView)->FocusIndex());

        }

    else if ( aOldView.iUid == KMSStoreListViewId.iUid )

        {

        // store focus index of fill view

        iParameterAgent->SetStoreViewFocusIndex(

                    static_cast<CMSStoreListView*> (iView)->FocusIndex());

        }        

    else

        {

        // no need to change view

        }

    // new view is activated

    ActivateViewL(TVwsViewId(KUidMediaServant, aNewView));

    }

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

// CMSAppUi::StoreListController()

// Returns fill rule container

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

//

CMSStoreListController* CMSAppUi::StoreListController()

    {

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

    return iStoreListController;

    }

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

// CMSAppUi::MSEngine()

// Returns msengine pointer

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

//

CMSEngine* CMSAppUi::MSEngine()

    {

    return iMSEngine;

    }

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

// CMSAppUi::RefreshListsL()

// Refresh store and fill lists

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

//

void CMSAppUi::RefreshListsL()    

    {

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

    iStoreListController->UpdateListsL();

    iFillRuleController->UpdateArrayL();

    }

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

// CMSFillView::ReadMMCInfoL

// Reads mmc capasity

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

//

TInt CMSAppUi::ReadMMCInfoL( TInt64& aCapasity, TInt64& aFreeSpace )

    {

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

    RFs& sysFs = FsSession();

    RPointerArray<CCmDriveInfo> storedDrives;

    RPointerArray<CCmDriveInfo> driveArray;

    TInt error = KErrNone;

    aCapasity = 0;

    aFreeSpace = 0;

    MCmSettings* settings = CCmSettingsFactory::NewCmSettingsEngineLC();

    // read stored info of stored drives

    MSEngine()->GetDrivesL( storedDrives );

    // get system drive info

    settings->DriveListL( sysFs, driveArray );

    TInt count = storedDrives.Count();

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

        {

        TIdentityRelation<CCmDriveInfo> relation( CMSAppUi::CompareIds );

        TInt index = driveArray.Find( storedDrives[i], relation );

        if ( index != KErrNotFound )

            {

            TVolumeInfo volInfo;

            error = sysFs.Volume( volInfo, storedDrives[i]->DriveNumber() );

            if ( error == KErrNone )

                {

                TRACE(Print(_L("[MediaServant]\t CMSAppUi::ReadMMCInfoL %ld\n"),

                            volInfo.iSize ));

                aCapasity += volInfo.iSize;

                aFreeSpace += volInfo.iFree;

                }

            }

        }

    storedDrives.ResetAndDestroy();

    storedDrives.Close();

    driveArray.ResetAndDestroy();

    driveArray.Close();

	settings->Close();

    CleanupStack::Pop(); // settings

    return error;

    }

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

// CMSAppUi::GetFilledFilesSize

// Get filled files size

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

//

void CMSAppUi::GetFilledFilesSize( TInt64& aSize, const TInt aID )

    {

    iMSEngine->GetFilledFilesSize( aSize, aID );

    }

// CMSAppUi::ParameterAgent

// returns pointer to parameter agent

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

//

CMSParameterAgent* CMSAppUi::ParameterAgent()

    {

    return iParameterAgent;

    }

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

// CMSAppUi::FillRuleController

// returns pointer to rule controller

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

//

CMSFillRuleController* CMSAppUi::FillRuleController()

    {

    return iFillRuleController;

    }

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

// CMSAppUi::FsSession

// returns file server session

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

//

RFs& CMSAppUi::FsSession()

    {

    return iEikonEnv->FsSession();

    }

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

// CMSAppUi::DriveSelectedL

// returns drive selection status

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

//

TBool CMSAppUi::DriveSelectedL()

    {

    TBool status( EFalse );

    if ( iMSEngine->DriveSelectionStatus() && MemoryAttachedL() )

        {

        status = ETrue;

        }

    return status;

    }

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

// CMSAppUi::MemoryAttachedL

// Returns ETrue if selected memory is on the device

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

//

TBool CMSAppUi::MemoryAttachedL()

    {

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

    TBool status( EFalse );

    RFs& fileServer = FsSession();

    RPointerArray<CCmDriveInfo> storedDrives;

    RPointerArray<CCmDriveInfo> driveArray;

    MCmSettings* settings = CCmSettingsFactory::NewCmSettingsEngineLC();

    // read stored info of stored drives

    MSEngine()->GetDrivesL( storedDrives );

    // get system drive info

    settings->DriveListL( fileServer, driveArray );

    TInt count = storedDrives.Count();

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

        {

        TIdentityRelation<CCmDriveInfo> relation(CMSAppUi::CompareIds );

        TInt index = driveArray.Find( storedDrives[i], relation );

        if ( index != KErrNotFound )

            {

            status = ETrue;

            i = count; // break loop

            }

        }

    storedDrives.ResetAndDestroy();

    storedDrives.Close();

    driveArray.ResetAndDestroy();

    driveArray.Close();

	settings->Close();

    CleanupStack::Pop(); // settings

    return status;

    }

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

// CMSAppUi::CompareIds

// Compares drive ids

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

//

TBool CMSAppUi::CompareIds( const CCmDriveInfo& aStoredDrive,

                            const CCmDriveInfo& aDrive )

    {

    TBool retval = EFalse;

    if ( aStoredDrive.DriveId() == aDrive.DriveId() )

        {

        retval = ETrue;

        }

    return retval;

    }

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

// CMSAppUi::LoadSettingsPluginL

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

//    

void CMSAppUi::LoadSettingsPluginL()

    {

    LOG(_L("[MediaServant]\t CMSAppUi::LoadSettingsPluginL start"));

    TRAPD( error, iPlugin = CMSGSInterface::NewL( KMSGSImplementationUid ) );

    if ( !error )

        {

        AddViewL( iPlugin ); // transfer ownership to CAknViewAppUi    

        }    

    LOG(_L("[MediaServant]\t CMSAppUi::LoadSettingsPluginL end"));

    }

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

// CMSAppUi::SettingsPlugin

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

// 

CMSGSInterface* CMSAppUi::SettingsPlugin()

    {

    return iPlugin;

    }

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

// CMSAppUi::CheckDrivesSelectedL

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

// 

void CMSAppUi::CheckDrivesSelectedL()

    {

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

    TBool status( EFalse );

    RFs& fileServer = FsSession();

    MCmSettings* settings = CCmSettingsFactory::NewCmSettingsEngineLC();

    RPointerArray<CCmDriveInfo> storedDrives;

    RPointerArray<CCmDriveInfo> driveArray;

    CleanupClosePushL( storedDrives );

    CleanupClosePushL( driveArray );

    // read stored info of stored drives

    MSEngine()->GetDrivesL( storedDrives );

    // get system drive info

    settings->DriveListL( fileServer, driveArray );

    TInt count = storedDrives.Count();

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

        {

        TIdentityRelation<CCmDriveInfo> relation(CMSAppUi::CompareIds );

        TInt index = driveArray.Find( storedDrives[i], relation );

        if ( index != KErrNotFound )

            {

            status = ETrue;

            i = count; // break loop

            }

        }

    // none of drives have been selected

    if( !status )

        {

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

            {

            // mass memory

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

                {

                RPointerArray<CCmDriveInfo> massDrives;

                CleanupClosePushL( massDrives );

                TInt64 quota =

                ( driveArray[j]->DriveSize() * KHDDefaultQuota ) / 100;

                driveArray[j]->SetDriveQuota( quota );

                driveArray[j]->SetStatus( ETrue );

                massDrives.AppendL( driveArray[j] );

                MSEngine()->SetDrivesL( massDrives );

                CleanupStack::PopAndDestroy(  );// &massDrives

                //break, for only one mass memory exist

                j = driveArray.Count();

                }

            }

        }

    storedDrives.ResetAndDestroy();

    driveArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( 2 ); // &storedDrives, &driveArray

	settings->Close();

    CleanupStack::Pop(); // settings

    }

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

// CMSAppUi::RunWizard

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

// 

TInt CMSAppUi::RunWizardL()

	{

	LOG(_L("[MediaServant]\t CMSAppUi::RunWizardL Launch Wizard"));

	TInt wizRetVal(KErrNone);

    // Check drives selection status

    CheckDrivesSelectedL();

    CMSAppWizard* appWizard = CMSAppWizard::NewL( *iMSEngine );

    CleanupStack::PushL( appWizard );

    wizRetVal = appWizard->StartL();

    CleanupStack::PopAndDestroy( appWizard );