/*

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

*

*/

#include <AknIconArray.h>

#include <mediaservant.rsg>

#include <mediaservant.mbg>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include "mserv.hlp.hrh"

#include "cmfillrule.h"

#include "msappui.h"

#include "msmainview.h"

#include "mediaservantuid.h"

#include "msmaincontainer.h"

#include "msengine.h"

#include "msconstants.h"

#include "msdebug.h"

// Constants

const TInt KTimerInterval = 60000000; // 1 min

const TInt KNaviTimerInterval = 2000000; // 2 sec

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

// CMSMainContainer::CMSMainContainer()

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

//

CMSMainContainer::CMSMainContainer( CMSAppUi& aAppUi,

                                    CMSMainView& aView )

    {

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

    iAppUi = &aAppUi;

    iView = &aView;

    iAppWizardRun = EFalse;

    }

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

// CMSMainContainer::~CMSMainContainer()

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

//

CMSMainContainer::~CMSMainContainer()

    {

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

    if( iPeriodic )

        {

        iPeriodic->Cancel();

        }

    delete iPeriodic;

    if( iNaviTimer )

        {

        iNaviTimer->Cancel();

        }    

    delete iNaviTimer;

    if( iUpdateList )

        {

        iUpdateList->Cancel();

        }

    delete iUpdateList;

    if( iMSPropertyWatcher )

        {

        iMSPropertyWatcher->Stop();

        }

    delete iMSPropertyWatcher;

    if( iMemoryCardMonitor )

        {

        iMemoryCardMonitor->Cancel();

        }

    delete iMemoryCardMonitor;

    delete iListBox; // Deletes listbox object.

    }

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

// CMSMainContainer::ConstructL()

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

//

void CMSMainContainer::ConstructL( TRect aRect )

    {

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

    // Create property watcher for progress info

    iMSPropertyWatcher = CMSPropertyWatcher::NewL();

    // view will observe changes in property

    iMSPropertyWatcher->SetObserver(this);

    //create a mmc monitor to capture mmc event

    RFs& systemFs = CEikonEnv::Static()->FsSession();

    iMemoryCardMonitor = CMSMemoryCardMonitor::NewL( this, systemFs );

    iMemoryCardMonitor->StartMonitor();

    CreateWindowL();

    iListBox = new (ELeave) CAknDoubleLargeStyleListBox;

    SetListBoxFromResourceL(iListBox, R_MAIN_VIEW_LISTBOX);

    // Create icons

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

    CleanupStack::PushL( icons );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath( AknIconUtils::AvkonIconFileName() );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_sync,

                        EMbmMediaservantQgn_mserv_sync_mask );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_sync_stop,

                        EMbmMediaservantQgn_mserv_sync_stop_mask );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_to_home,

                        EMbmMediaservantQgn_mserv_to_home_mask );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_to_home_inactive,

                        EMbmMediaservantQgn_mserv_to_home_inactive_mask );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_from_home,

                        EMbmMediaservantQgn_mserv_from_home_mask );

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_from_home_inactive,

                        EMbmMediaservantQgn_mserv_from_home_inactive_mask );

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

    CleanupStack::Pop(icons);

    // Container is listbox observer

    iListBox->SetListBoxObserver( this );

    // Set engine observer

    iAppUi->MSEngine()->SetObserver( this );

    SetRect(aRect);

    // Check if automatic sync/harvest is ongoing

    TCmServerState state;

    iAppUi->MSEngine()->ServerState( state );

    if ( state == ECmServerStateStoring ||

         state == ECmServerStateFilling ||

         state == ECmServerStateSearchingForServers )

        {

        iSyncRunning = ESyncRunning;

         }

    if ( state == ECmServerStateHarvesting )

        {

        iRefreshRunning = ETrue;

        }

    // From home secondary item text depends list selections

    iFillListSelected = CheckIfFillListSelected();

    // Add data to listbox

    UpdateListBoxDataL();

    if ( iSyncRunning != ESyncRunning &&

         iRefreshRunning == EFalse &&

         state != ECmServerStateDeleting )

        {

        // Set last sync time to navi pane

        SetNaviTextLastSyncL();

        }

    // Delete may be in progress so we have to inform user

    if ( state == ECmServerStateDeleting )

        {

        HBufC* naviText = StringLoader::LoadLC( R_MS_PREPROCESSING_TEXT );

        iView->SetNavigationPaneTextL( *naviText );

        CleanupStack::PopAndDestroy( naviText );

        }

    // start listening property

    iMSPropertyWatcher->StartL();

    //Set current item

    iListBox->SetCurrentItemIndex(

                        iAppUi->ParameterAgent()->MainViewFocusIndex() );

    // Start timer for last sync time reading

    iPeriodic = CPeriodic::NewL(CActive::EPriorityIdle);

    iPeriodic->Start( 0, KTimerInterval, TCallBack(TimerCallbackL,this) );

    // create navi text timer - don't start

    iNaviTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    iUpdateList = CIdle::NewL( CActive::EPriorityIdle );

    ActivateL(); // Activates window. ( Ready to draw )

    }

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

// CMSMainContainer::CountComponentControls()

// Returns number of components.

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

//

TInt CMSMainContainer::CountComponentControls() const

    {

    return 1; // return number of controls inside this container

    }

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

// CMSMainContainer::ComponentControl()

// Returns pointer to particular component.

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

//

CCoeControl* CMSMainContainer::ComponentControl( TInt aIndex ) const

    {

    CCoeControl* retval = NULL;

    switch ( aIndex )

        {

        case 0:

            {

            retval = iListBox; // return a pointer to the listbox

            break;

            }

        default:

            {

            retval = NULL;

            break;

            }

        }

    return retval;

    }

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

// CMSMainContainer::OfferKeyEventL()

// Handles the key events.

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

//

TKeyResponse CMSMainContainer::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

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

    TKeyResponse response = EKeyWasNotConsumed;

    if ( aType != EEventKey )

        {

        response =  EKeyWasNotConsumed;

        }

    if ( iListBox )

        {

        response = iListBox->OfferKeyEventL( aKeyEvent, aType );

        }

    iView->SetCbaL( iListBox->CurrentItemIndex() );

    return response;

    }

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

// CMSMainContainer::OpenSelectedListboxItemL

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

//

void CMSMainContainer::OpenSelectedListboxItemL()

    {

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

    HandleListBoxEventL( NULL, EEventEnterKeyPressed );

    }

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

// CMSMainContainer::HandleListBoxEventL()

// Handles listbox event.

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

void CMSMainContainer::HandleListBoxEventL(

    CEikListBox* /*aListBox*/,

    TListBoxEvent aEventType )

    {

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

    if ( ( aEventType == MEikListBoxObserver::EEventEnterKeyPressed ) ||

         ( aEventType == MEikListBoxObserver::EEventItemClicked ) )

        {

        TInt selected = iListBox->CurrentItemIndex();

        switch ( selected )

            {

            case EStoreAndFill:

                {

                // refresh is not active

                if ( !iRefreshRunning )

                    {

                    if ( iSyncRunning == ESyncNotRunning )

                        {

                        StartSyncL();

                        }

                    else

                        {

                        // Cancel current asyncronous operation

                        iAppUi->MSEngine()->StopOperation();

                        iSyncRunning = ESyncNotRunning;

                        iView->ClearCurrentNaviPaneText();

                        UpdateListBoxDataL();

                        }

                    }

                 // refresh is ongoing

                 else

                    {

                    if ( iSyncRunning == ESyncWaiting )

                        {

                        iSyncRunning = ESyncNotRunning;

                        }

                    else

                        {

                        iSyncRunning = ESyncWaiting;

                        }

                    UpdateListBoxDataL();

                    }

                break;

                }

            case EStoreToNetwork:

                {

                if ( !iRefreshRunning && 

                     !iSyncRunning && 

                     !iPreprocessRunning )

                    {

                    iAppUi->ChangeViewL( KMSMainViewId,

                                         KMSStoreListViewId );

                    }

                else

                    {

                    TInt noteId = ( iRefreshRunning || iPreprocessRunning ?

                                    R_MS_ACCESS_ERROR_NOTE : 

                                    R_MS_ACCESS_ERROR_NOTE_SYNC );

                    ShowErrorNoteL( noteId );

                    }

                break;

                }

            case EFillToPhone:

                {

                if ( iAppUi->DriveSelectedL() )

                    {

                    if ( !iRefreshRunning &&

                         !iSyncRunning &&

                         !iPreprocessRunning )

                        {

                        iAppUi->ChangeViewL( KMSMainViewId, KMSFillViewId );

                        }

                    else

                        {

                        TInt noteId = ( iRefreshRunning ||

                                        iPreprocessRunning ?

                                        R_MS_ACCESS_ERROR_NOTE : 

                                        R_MS_ACCESS_ERROR_NOTE_SYNC );

                        ShowErrorNoteL( noteId );

                        }

                    }

                else

                    {

                    ShowErrorNoteL( R_MS_INSERT_MEMORY_CARD_TEXT );

                    }

                break;

                }

            default:

                {

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

                HandleListBoxEventL no item selected"));

                }

            }

        }

    }

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

// CMSMainContainer::UpdateListBoxDataL()

// Updates listbox texts

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

//

void CMSMainContainer::UpdateListBoxDataL()

    {

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

    TCmServerState state;

    iAppUi->MSEngine()->ServerState( state );

    CDesCArray* itemArray = static_cast<CDesCArray*>

                                        (iListBox->Model()->ItemTextArray());

    if ( itemArray->Count() )

        {

        // delete all listbox items

        itemArray->Reset();

        }

    // Get file counts and sync time

    TInt itemsToBeStored( 0 );

    TInt itemsToBeFilled( 0 );

    TInt syncTime( 0 );

    TInt syncTimeStore( 0 );

    TInt syncTimeFill( 0 );

    iAppUi->MSEngine()->GetTransferInfo( ECmServiceStore,

                                         itemsToBeStored,

                                         syncTimeStore );

    iAppUi->MSEngine()->GetTransferInfo( ECmServiceFill,

                                         itemsToBeFilled,

                                         syncTimeFill );

    syncTime = syncTimeStore + syncTimeFill;

    // Create item strings

    HBufC* primaryText = NULL;

    HBufC* secondaryText = NULL;

    TInt icon = EIconSync;

    switch ( iSyncRunning )

        {

        default:

        // fall trough

        case ESyncNotRunning:

            {

            primaryText = StringLoader::LoadLC( R_MAIN_SYNC_NOW_TEXT );

            if ( itemsToBeStored > 0 || itemsToBeFilled > 0)

                {

                if ( syncTime/60 > 1 ) // 1 minute

                    {

                    secondaryText = StringLoader::LoadLC(

                                                    R_MS_SYNC_TIME_TEXT,

                                                    syncTime/60 );

                    // do number conversion

                    TPtr ptr = secondaryText->Des();

                    AknTextUtils::

                        DisplayTextLanguageSpecificNumberConversion( ptr );

                    }

                else

                    {

                    secondaryText = StringLoader::LoadLC(

                                               R_MS_SYNC_TIME_ONE_MIN_TEXT );

                    }

                }

            break;

            }

        case ESyncRunning:

            {

            primaryText = StringLoader::LoadLC( R_MAIN_STOP_SYNC_TEXT );

            icon = EIconSyncStop;

            break;

            }

        case ESyncWaiting:

            {

            primaryText = StringLoader::LoadLC( R_MAIN_STOP_SYNC_TEXT );

            secondaryText = StringLoader::LoadLC( R_MS_SYNC_WAITING_TEXT );

            icon = EIconSyncStop;

            break;

            }

        }

    AppendItemToListBoxArrayL( iListBox,

                               iListBox->Model(),

                               icon,

                               *primaryText,

                               *secondaryText );

    if ( secondaryText )

        {

        CleanupStack::PopAndDestroy( secondaryText );

        secondaryText = NULL;

        }

    if ( primaryText )

        {

        CleanupStack::PopAndDestroy( primaryText );

        primaryText = NULL;

        }

    // From Home -item

    primaryText = StringLoader::LoadLC( R_MAIN_FROM_HOME_TEXT );

    TBool driveSelected = iAppUi->DriveSelectedL();

    if ( driveSelected == EFalse )

        {

        secondaryText = StringLoader::LoadLC( R_MS_MEMORY_CARD_NEEDED_TEXT );

        }

    else if ( !iFillListSelected )

        {

        secondaryText = StringLoader::LoadLC( R_MS_LIST_NOTHING_SELECTED );

        }