/*

* 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 the class CFMRadioScanLocalStationsView

*

*/

// INCLUDE FILES

#include <AknWaitDialog.h> 

#include <featmgr.h>

#include <aknViewAppUi.h>

#include <aknnotedialog.h>

#include <akntitle.h>

#include <aknnotewrappers.h> // for basic note

#include <aknbutton.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <StringLoader.h>

#include <eikmenup.h>

#include <eikbtgpc.h>

#include <fmradio.rsg>

#include <fmradio.mbg>

#include <fmradiouids.h>

#include <data_caging_path_literals.hrh>

#include <akntoolbar.h>

#include "fmradiobacksteppingservicewrapper.h"

#include "fmradioengine.h"

#include "fmradiordsreceiverbase.h"

#include "fmradio.hrh"

#include "fmradioscanlocalstationsview.h"

#include "fmradiopreset.h"

#include "fmradioscanlocalstationscontainer.h"

#include "debug.h"

#include "fmradioappui.h"

const TInt KMSKControlID(3);

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

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

// CFMRadioScanLocalStationsView::NewL

// Two-phase constructor of CFMRadioScanLocalStationsView

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

//

CFMRadioScanLocalStationsView* CFMRadioScanLocalStationsView::NewL( CRadioEngine& aRadioEngine,

		MChannelListHandler& aObserver )

    {

    CFMRadioScanLocalStationsView* self = new (ELeave) CFMRadioScanLocalStationsView( aRadioEngine, 

    		aObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self; 

    }

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

// CFMRadioScanLocalStationsView::CFMRadioScanLocalStationsView

// Parameter constructor ( default constructor )

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

//

CFMRadioScanLocalStationsView::CFMRadioScanLocalStationsView( CRadioEngine& aRadioEngine,

    MChannelListHandler& aObserver ):

    iNowPlayingIndex( KErrNotFound ),

    iScanAndSaveActivated( EFalse ),

    iScanCancelled( EFalse ),

    iRadioEngine( aRadioEngine ),

    iTuneRequested( EFalse ),

    iObserver( aObserver ),

    iCancelType( EFMRadioCancelScanDefault )

    {

    }

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

// CFMRadioScanLocalStationsView::ConstructL

// EPOC two-phased constructor

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

//

void CFMRadioScanLocalStationsView::ConstructL()

    {

    BaseConstructL( R_FMRADIO_SEARCH_STATIONS_VIEW );

    PrepareToolbar();

    }

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

// CFMRadioScanLocalStationsView::~CFMRadioScanLocalStationsView

// Class destructor

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

//

CFMRadioScanLocalStationsView::~CFMRadioScanLocalStationsView()

    {

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        delete iContainer;

    	iContainer = NULL;

        }

    if ( iScanningNote )

    	{

    	TRAP_IGNORE( iScanningNote->ProcessFinishedL() );

    	iScanningNote = NULL;

    	}

    iScannedChannels.ResetAndDestroy();

    iScannedChannels.Close();

    }

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

// CFMRadioScanLocalStationsView::Id

// Return the unique identifier corresponding to this view

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

//

TUid CFMRadioScanLocalStationsView::Id() const

    {

    return KFMRadioScanLocalStationsViewId;

    }

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

// CFMRadioScanLocalStationsView::DoActivateL

// Activate the channel list view

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

//

void CFMRadioScanLocalStationsView::DoActivateL( const TVwsViewId& /*aPrevViewId*/,

												 TUid /*aCustomMessageId*/,

												 const TDesC8& /*aCustomMessage*/ )

    {

    FTRACE( FPrint( _L("CFMRadioScanLocalStationsView::DoActivateL  Start") ) );

    Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); 

    Cba()->DrawDeferred(); // Redraw softkeys

    HBufC* title = StringLoader::LoadLC( R_FMRADIO_SEARCH_STATIONS_VIEW_TITLE, iCoeEnv );

    static_cast<CAknTitlePane*>( StatusPane()->ControlL( 

        TUid::Uid( EEikStatusPaneUidTitle ) ) )->SetTextL( *title );

    CleanupStack::PopAndDestroy( title );

    if ( !iContainer )

        {

        FTRACE( FPrint( _L("CFMRadioScanLocalStationsView::DoActivateL  inside second, not iContainer if") ) );

        iContainer = CFMRadioScanLocalStationsContainer::NewL( ClientRect(), iRadioEngine );

        iContainer->SetMopParent( this );

        iContainer->SetObserver( this );

        AppUi()->AddToStackL( *this, iContainer );

        }

    AppUi()->HandleCommandL( EFMRadioCmdScanLocalStationsViewActive );

    ResetListAndStartScanL();

    iRadioEngine.RdsReceiver().AddObserver( this );

    }

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

// CFMRadioScanLocalStationsView::HandleCommandL

// Interprets view's menu,softkey and other commands and acts

// accordingly by calling the appropriate command handler

// function for further action.

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

//

void CFMRadioScanLocalStationsView::HandleCommandL( TInt aCommand )

    {

    CFMRadioAppUi* appUi = static_cast<CFMRadioAppUi*>( AppUi() );

    switch ( aCommand )

        {

        case EAknSoftkeyBack: // go back to the main view

            {

            appUi->ActivateLocalViewL( KFMRadioChannelListViewId );

            break;

            }

        case EEikBidCancel:

            {

            if ( iFaded )

                {

                appUi->HandleCommandL( aCommand );

                }

            else

                {

                appUi->ActivateLocalViewL( KFMRadioChannelListViewId );

                }

            break;

            }

        case EFMRadioCmdSaveChannel:

            {

            HandleOneChannelSaveL();

            break;      	        

        	}        	

        case EFMRadioCmdSaveAllChannels:

            SaveAllChannelsL();

            break;

        case EFMRadioCmdScanLocalStationsScan: // start station scanning

            {

            Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); 

            Cba()->DrawDeferred(); // Redraw softkeys

            //reset all counters, make station list empty

            ResetListAndStartScanL();

        	break;

        	}

        case EFMRadioCmdListenCh:

        	{

        	PlayCurrentlySelectedChannelL();

        	SetContextMenu( R_FMRADIO_SCAN_STATIONS_CTX_MENUBAR_SAVE );

        	break;

        	}

        default: // Send all other commands to AppUi

            appUi->HandleCommandL( aCommand );

            break;

        }

    }

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

// CFMRadioScanLocalStationsView::SetLastListenedChannel

// Keep track of the last selected channel

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

//

void CFMRadioScanLocalStationsView::SetLastListenedChannel( TInt aIndex )

    {

    iChIndex = aIndex;

    if ( iContainer )

        {

        iContainer->UpdateLastListenedChannel( aIndex ); // Update index

        }

    }

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

// CFMRadioScanLocalStationsView::SetNowPlayingChannelL

// Keep track of the current selected channel

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

//

void CFMRadioScanLocalStationsView::SetNowPlayingChannelL( TInt aChannelIndex )

    {

    TInt oldIndex = iNowPlayingIndex;

    iNowPlayingIndex = aChannelIndex;

    if ( iContainer && ( aChannelIndex != oldIndex ) )

        {

        if ( ChannelInUse( oldIndex ) &&

                !iScannedChannels[ oldIndex ]->PresetNameValid() )

            {

            // Remove dynamic ps name

            iContainer->UpdateChannelListContentL( oldIndex,

                    KNullDesC,

                    iScannedChannels[ oldIndex ]->PresetFrequency(),

                    EFalse,

                    EFalse );

            }

        iContainer->UpdateNowPlayingIconL( iNowPlayingIndex, oldIndex );

        }

    }

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

// CFMRadioScanLocalStationsView::CurrentlyPlayingChannel

// Returns the index of the playing channel item from the channel list.

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

//

TInt CFMRadioScanLocalStationsView::CurrentlyPlayingChannel()

	{

	return iNowPlayingIndex;

	}

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

// CFMRadioScanLocalStationsView::ChannelInPlay

// Return true/false to indicate whether the channel specified

// is in play

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

//

TBool CFMRadioScanLocalStationsView::ChannelInPlay( TInt aChannelIndex ) const

    {

    if( aChannelIndex == iNowPlayingIndex )

    	{

    	return ETrue;

    	}

    else 

    	{

    	return EFalse;

    	}

    }

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

// CFMRadioScanLocalStationsView::ChannelInUse

// Return true/false to indicate whether the channel specified

// is in use

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

//

TBool CFMRadioScanLocalStationsView::ChannelInUse( const TInt aChannelIndex ) const

    {

    TBool ret = EFalse;

    FTRACE( FPrint( _L("CFMRadioScanLocalStationsView::ChannelInUse  Start") ) );

    if ( aChannelIndex >= KMinNumberOfChannelListItems &&

            aChannelIndex < iScannedChannels.Count() )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CFMRadioScanLocalStationsView::FadeAndShowExit

// Fade the view and all controls associated with it. Change

// the soft keys so that "Exit" is displayed

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

//

void CFMRadioScanLocalStationsView::FadeAndShowExit( TBool aFaded )

    {

    TInt err = KErrNone;

    iFaded = aFaded;

        {

        if ( aFaded ) // Fade

            {

            // In case options menu is open when headset is disconnected

            StopDisplayingMenuBar();

            iContainer->SetFaded( aFaded );

            TRAP( err,Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_EXIT ) );

            }

        else

            {

            TRAP( err,Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ) );

            // Update index to be sure it is up-to-date (in case if list was scrolled in idle state)

            iContainer->UpdateLastListenedChannel( iChIndex );

            if( iScannedChannels.Count() > 0 )

                TRAP_IGNORE( SetMiddleSoftKeyIconL(); )

            }

        Cba()->DrawDeferred();

        }

    }

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

// CFMRadioScanLocalStationsView::UpdateDisplayForFocusGained

// Update the view after a focus gained event.

// 1. Fade/Unfade view

// 2. Update MSK label

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

//

void CFMRadioScanLocalStationsView::UpdateDisplayForFocusGained()

    {

    FadeAndShowExit( iFaded );

    }

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

// CFMRadioScanLocalStationsView::UpdateChannelListContentL

// Make a request to the channel container to update the

// content of the channel at aIndex with the values specified

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

//

void CFMRadioScanLocalStationsView::UpdateChannelListContentL( TInt aIndex,

															   TInt aChannelFrequency )

    {

    TBool nowPlaying = EFalse;	

    if( ChannelInPlay( aIndex ) )

	    {

	    nowPlaying = ETrue;	

	    }

	else 

		{

		 nowPlaying = EFalse;	

		}

    if ( iContainer )

        {

        iContainer->UpdateChannelListContentL( aIndex, KNullDesC, aChannelFrequency, nowPlaying );

        }

    }

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

// CFMRadioScanLocalStationsView::CurrentlySelectedChannel

// Returns the index of the selected channel item from the

// channel list. If the container is active get the info from

// it, because it may have more up-to-date info.

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

//

TInt CFMRadioScanLocalStationsView::CurrentlySelectedChannel()

    {

    if ( iContainer )

        {

        iChIndex = iContainer->CurrentlySelectedChannel();

        }

    return iChIndex;

    }

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

// CFMRadioScanLocalStationsView::NextChannel

// Retrieve the index of the next channel that has been set.

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

//

TInt CFMRadioScanLocalStationsView::NextChannel()

    {

    if ( iContainer )

        {

        iChIndex = iContainer->CurrentlySelectedChannel();

        }

    else

        {

        iChIndex = iRadioEngine.GetPresetIndex();

        }

    TInt nextChannel = iChIndex;

    for ( TInt i = iChIndex + 1; i < KMaxNumberOfChannelListItems; i++ )

        {

        if ( ChannelInUse( i ) )

            {

            nextChannel = i;

            break;

            }

        }

    if ( nextChannel == iChIndex )

        {

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

            {

            if ( ChannelInUse( i ) )

                {

                nextChannel = i;

                break;

                }

            }

        }

    return nextChannel;

    }

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

// CFMRadioScanLocalStationsView::PreviousChannel

// Retrieve the index of the previous channel that has been set.

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

//

TInt CFMRadioScanLocalStationsView::PreviousChannel()

    {

    if ( iContainer )

        {

        iChIndex = iContainer->CurrentlySelectedChannel();

        }

    else

        {

        iChIndex = iRadioEngine.GetPresetIndex();

        }

    TInt previousChannel = iChIndex;

    for ( TInt i = iChIndex - 1; i >= 0; i-- )

        {

        if ( ChannelInUse( i ) )

            {

            previousChannel = i;

            break;

            }

        }

    if ( previousChannel == iChIndex )

        {

        for ( TInt i = KMaxNumberOfChannelListItems - 1; i > iChIndex; i-- )

            {

            if ( ChannelInUse( i ) )

                {

                previousChannel = i;

                break;

                }

            }

        }

    return previousChannel;

    }

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

// CFMRadioScanLocalStationsView::HandleControlEventL

// Handles control event observing. In this case the interest

// is only on the channel selection from the channel list.

// Other events are not reported by the container,

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

//

void CFMRadioScanLocalStationsView::HandleControlEventL( CCoeControl* aControl,

                                                         TCoeEvent aEventType )

    {

    if ( aControl == iContainer )

        {

        if ( aEventType == MCoeControlObserver::EEventRequestFocus )

            {

            // Don't display MSK when display is faded.

            if ( !iFaded && !AknLayoutUtils::PenEnabled() )

                {

                // event sent if up or down arrow keys are pressed

           	    if ( ( CurrentlyPlayingChannel() == CurrentlySelectedChannel() ) )

                    {

                    SetContextMenu( R_FMRADIO_SCAN_STATIONS_CTX_MENUBAR_SAVE );

                    }

                else

                    {

                	SetContextMenu( R_FMRADIO_SCAN_STATIONS_CTX_MENUBAR );

                    }

                }

            else if ( ChannelInUse( CurrentlySelectedChannel() ) )

                {

                PlayCurrentlySelectedChannelL();

                }

            }

        else if ( aEventType == MCoeControlObserver::EEventStateChanged

                && ChannelInUse( CurrentlySelectedChannel() ) )

            {

            PlayCurrentlySelectedChannelL();

            }

        }

    }

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

// CFMRadioScanLocalStationsView::DoDeactivate

// Deactivate the channel list view