/*

* Copyright (c) 2005 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 CFMRadioChannelListView

*

*/

// INCLUDE FILES

#include <featmgr.h>

#include <aknViewAppUi.h>

#include <akntitle.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 <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <data_caging_path_literals.hrh>

#include <aknbutton.h>

#include <akntoolbar.h>

#include "fmradioengine.h"

#include "fmradio.hrh"

#include "fmradiochannellistview.h"

#include "fmradiochannellistcontainer.h"

#include "debug.h"

#include "fmradiordsreceiverbase.h"

#include "fmradiopubsub.h"

#include "fmradiofrequencyquerydialog.h"

#include "fmradioappui.h"

const TInt KMSKControlID(3);

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

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

// CFMRadioChannelListView::NewL

// Two-phase constructor of CFMRadioChannelListView

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

//

CFMRadioChannelListView* CFMRadioChannelListView::NewL(

    CRadioEngine* aRadioEngine, MChannelListHandler& aObserver )

    {

    CFMRadioChannelListView* self = new ( ELeave ) CFMRadioChannelListView( aObserver );

    CleanupStack::PushL(self);

    self->ConstructL(aRadioEngine);

    CleanupStack::Pop( self );

    return self;

    }

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

// CFMRadioChannelListView::CFMRadioChannelListView

//

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

//

CFMRadioChannelListView::CFMRadioChannelListView( MChannelListHandler& aObserver ) :

    iNowPlayingIndex( KErrNotFound ),

	iObserver( aObserver )	

	{

	}

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

// CFMRadioChannelListView::ConstructL

// EPOC two-phased constructor

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

//

void CFMRadioChannelListView::ConstructL(

    CRadioEngine* aRadioEngine)

    {    

    iRadioEngine = aRadioEngine;

    BaseConstructL( R_FMRADIO_CH_LIST_VIEW );

    PrepareToolbar();

    if ( !AknLayoutUtils::PenEnabled() )

        {

        iToolbar->SetToolbarVisibility( EFalse );

        }

    //called here to ensure that empty channels are named in the way we want them to be.

    InitializeChannelsL();

    }

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

// CFMRadioChannelListView::~CFMRadioChannelListView

// Class destructor

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

//

CFMRadioChannelListView::~CFMRadioChannelListView()

    {

    if ( iContainer )

        {

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

        }

    delete iContainer;

    }

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

// CFMRadioChannelListView::Id

// Return the unique identifier corresponding to this view

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

//

TUid CFMRadioChannelListView::Id() const

    {

    return KFMRadioChannelListViewId;

    }

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

// CFMRadioChannelListView::DoActivateL

// Activate the channel list view

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

//

void CFMRadioChannelListView::DoActivateL(

    const TVwsViewId& /*aPrevViewId*/,

    TUid /*aCustomMessageId*/,

    const TDesC8& /*aCustomMessage*/ )

    {

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

    iRadioEngine->RdsReceiver().AddObserver(this);

    iFirstMoveDone = ETrue;

    SetTitleL( R_FMRADIO_STATIONS_VIEW_TITLE );

    if ( !iContainer )

        {

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

        iContainer = CFMRadioChannelListContainer::NewL( ClientRect(), *iRadioEngine, iObserver );

        iContainer->SetMopParent( this );

        iContainer->SetObserver( this );

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

        }

    InitializeChannelsL();

    FadeAndShowExit( iFaded );

    AppUi()->HandleCommandL( EFMRadioCmdChannelListViewActive );

    UpdateMiddleSoftKeyL();

    }

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

// CFMRadioChannelListView::HandleCommandL

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

// accordingly by calling the appropriate command handler

// function for further action.

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

//

void CFMRadioChannelListView::HandleCommandL( TInt aCommand )

    {

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

    switch ( aCommand )

        {

    	case EFMRadioCmdMove:

        	{

            MoveCurrentItemIndexL();

        	break;

        	}

    	case EFMRadioCmdDone:

    		{

    		iMoveMode = EFalse;

    		iFirstMoveDone = ETrue;

    		Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );

    		UpdateMiddleSoftKeyL();

    		iContainer->MoveDoneL();

            TInt currentIndex = 0;

            currentIndex = appUi->MatchingChannelL( iRadioEngine->GetTunedFrequency() );

            if ( currentIndex != KErrNotFound )

                {

                iRadioEngine->SetCurrentPresetIndex( currentIndex );

                SetNowPlayingChannel( currentIndex );

                }

            ShowToolbar( ETrue );

    		break;

    		}

    	case EFMRadioCmdDrop:

    		{

    		iFirstMoveDone = EFalse;

    		Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_GRAP_DONE );    		    		

    		iContainer->HandleDropL();

    		break;

    		}

    	case EFMRadioCmdGrap:

    		{

        	if ( iFirstMoveDone )

        		{

                Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_DROP_CANCEL );

        		}

        	else

        		{

                Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_DROP_DONE );

        		}

        	iContainer->ActivateMoveL();

        	break;

    		}

        case EAknSoftkeyBack:   // Go back to the main view

            {

            appUi->ActivateLocalViewL( KFMRadioMainViewId );

            break;

            }

        case EEikBidCancel:

            {

            CancelMoveL();

            break;

            }

        case EAknSoftkeySelect: // Save a channel to the highlighted slot

            {

            break;

            }

        case EFMRadioCmdTuneManually:

        	{

        	// If manual tuning is canceled, return to previously tuned frequency. 	

			TUint32 prevFreq = iRadioEngine->GetTunedFrequency() / KFMRadioFreqMultiplier;

			TUint32 retFreq = prevFreq;

			iManualQueryDialog = CFMRadioFrequencyQueryDialog::NewL( retFreq );            

            iManualQueryDialog->SetObserver( this );

			TInt res = iManualQueryDialog->ExecuteLD( R_FMRADIO_MANUAL_TUNING_QUERY );

			if ( res )

				{				

                if ( iObserver.Channels().Count() < KMaxNumberOfChannelListItems )

					{

					TInt usefreq = static_cast<TInt>( retFreq * KFMRadioFreqMultiplier );

					iRadioEngine->Tune( usefreq );

					TBuf<KPresetNameLength> stationName;

					stationName.SetLength( 0 );

					iObserver.AddChannelToListL( stationName, usefreq );

					iObserver.UpdateChannelsL( EStoreAllToRepository, 0, 0 );

					iContainer->AddChannelL( stationName, usefreq, ETrue );	

                    iRadioEngine->TunePresetL( iObserver.Channels().Count() - 1 );

					TInt index = iRadioEngine->GetPresetIndex();

					iContainer->UpdateItemIconL( index, KNowPlayingIconIndexChList );

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

					}

				else

					{

					// Show icon, or overwrite last item, or selected item?

					CAknInformationNote* infonote = new( ELeave ) CAknInformationNote();

				    HBufC* noteText = StringLoader::LoadLC( 

				    		R_QTN_FMRADIO_LIST_QUERY_LIST_FULL, iCoeEnv );

				    infonote->ExecuteLD( *noteText );

				    CleanupStack::PopAndDestroy( noteText );					

					}					

				}

			else //cancel pressed, return to previous frequency

				{

				iRadioEngine->Tune( static_cast<TInt>( prevFreq * KFMRadioFreqMultiplier ) );				

				}

        	break;

        	}

        case EFMRadioCmdListenCh:

            {

            if ( !AknLayoutUtils::PenEnabled() )

                {

                appUi->HandleCommandL( aCommand );

                // update msk here

                UpdateMiddleSoftKeyL();

                }

            if ( iMoveMode )

                {

                MoveActionDoneL();

                }

            break;

            }

        case EFMRadioToolbarButtonCmdToggleIhf:

            {

            if ( iRadioEngine->GetAudioOutput() == CRadioEngine::EFMRadioOutputHeadset )

                {

                appUi->HandleCommandL( EFMRadioCmdActivateIhf );

                }

            else

                {

                appUi->HandleCommandL( EFMRadioCmdDeactivateIhf );

                }

            break;

            }

        case EFMRadioCmdErase:

            {

                {

                    {

                    }

                }

            break;

            }

        default: // Send all other commands to AppUi

        	{        		        	

        	appUi->HandleCommandL( aCommand );

            break;

        	}

        }

    }

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

// CFMRadioChannelListView::SetLastListenedChannel

// Keep track of the last selected channel

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

//

void CFMRadioChannelListView::SetLastListenedChannel( TInt aIndex )

    {

    iChIndex = aIndex;

    if ( iContainer && !iMoveMode )

        {

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

        }

    }

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

// CFMRadioChannelListView::SetNowPlayingChannel

// Keep track of the current selected channel

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

//

void CFMRadioChannelListView::SetNowPlayingChannel( TInt aChannelIndex ) 

    {

    iNowPlayingIndex = aChannelIndex;

    if ( iContainer && !iMoveMode )

        {

        TRAP_IGNORE( iContainer->UpdateItemIconL( aChannelIndex, KNowPlayingIconIndexChList ) )

        }

    }

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

// CFMRadioChannelListView::CurrentlyPlayingChannel

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

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

//

TInt CFMRadioChannelListView::CurrentlyPlayingChannel()

	{

	return iNowPlayingIndex;

	}

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

// CFMRadioChannelListView::InitializeChannelsL

// Initialize the channels with the values currently saved in

// the radio engine

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

//

void CFMRadioChannelListView::InitializeChannelsL()

    {

    FTRACE( FPrint( _L("CFMRadioChannelListView::InitializeChannelsL  Start") ) );

    if ( iContainer )

        {

        TBool nowPlaying = EFalse;

        RPointerArray<CFMRadioPreset>& channels = iObserver.Channels();        

        TInt channelCount = channels.Count();

        for ( TInt channelIndex = 0; channelCount > channelIndex; channelIndex++ )

            {

            FTRACE( FPrint( _L("CFMRadioChannelListView::InitializeChannelsL  inside Channel in use") ) );

            iContainer->AddChannelL( channels[ channelIndex ]->PresetName(),

                   channels[ channelIndex ]->PresetFrequency(),

                   nowPlaying );

            UpdateMiddleSoftKeyL();

            FTRACE( FPrint( _L("CFMRadioChannelListView::InitializeChannelsL  inside Channel in use Channel = %d"), iRadioEngine->GetPresetFrequencyL( channelIndex )) );

            }

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

        TInt currentPresetIndex = iRadioEngine->GetPresetIndex();

        TInt chIndexForTunedFreq = appUi->MatchingChannelL( iRadioEngine->GetTunedFrequency() );

        if ( iRadioEngine->GetRadioMode() == CRadioEngine::ERadioPresetMode &&

                currentPresetIndex < channelCount &&

                currentPresetIndex >= 0 )

            {

            SetLastListenedChannel( currentPresetIndex );

            SetNowPlayingChannel( currentPresetIndex );

            }

        else if ( chIndexForTunedFreq != KErrNotFound )

            {

            SetLastListenedChannel( chIndexForTunedFreq );

            SetNowPlayingChannel( chIndexForTunedFreq );

            }

        else

            {

            SetLastListenedChannel( 0 );

            }

        }

    FTRACE(FPrint(_L("InitializeChannelsL complete")));

    }

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

// CFMRadioChannelListView::ChannelInPlay

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

// is in play

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

//

TBool CFMRadioChannelListView::ChannelInPlay(

    TInt aChannelIndex ) const

    {

    if( aChannelIndex == iNowPlayingIndex )

    	{

    	return ETrue;

    	}

    else 

    	{

    	return EFalse;

    	}

    }

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

// CFMRadioChannelListView::FadeAndShowExit

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

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

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

//

void CFMRadioChannelListView::FadeAndShowExit( TBool aFaded )

    {

    iFaded = aFaded;

    if( iContainer && iToolbar )

        {

        if ( aFaded ) // Fade

            {

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

            StopDisplayingMenuBar();

            iContainer->SetFaded( aFaded );

            iToolbar->SetDimmed( ETrue );

            TRAP_IGNORE( Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_EXIT ) );

            }

        else

            {

            iContainer->SetFaded(aFaded);

            iToolbar->SetDimmed( EFalse );

            UpdateToolbar();

            if ( iMoveMode )

                {

                TRAP_IGNORE

                    (

                    Cba()->SetCommandSetL( R_FMRADIO_SOFTKEYS_EMPTY_CANCEL );

                    UpdateMiddleSoftKeyL();

                    )

                }

            else

                {

                TRAP_IGNORE( Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ) );

                }

            }

        Cba()->DrawDeferred();

        iToolbar->DrawDeferred();

        }

    }

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

// CFMRadioChannelListView::UpdateDisplayForFocusGained

// Update the view after a focus gained event.

// 1. Fade/Unfade view

// 2. Update MSK label

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

//

void CFMRadioChannelListView::UpdateDisplayForFocusGained()

    {

    FadeAndShowExit( iFaded );

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

    if ( !iFaded )

    	{

    	TRAP_IGNORE( UpdateMiddleSoftKeyL() );

    	}

    }

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

// CFMRadioChannelListView::UpdateChannelListContentL

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

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

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

//

void CFMRadioChannelListView::UpdateChannelListContentL(

    TInt aIndex,

    const TDesC& aChannelName,

    TInt aChannelFrequency )

    {

    if ( iContainer )

        {

        iContainer->UpdateChannelListContentL( aIndex, aChannelName, aChannelFrequency );

        }

    }

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

// CFMRadioChannelListView::CurrentlySelectedChannel

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

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