/*

* 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:  FM Radio App UI implementation

*

*/

// INCLUDE FILES

#include <featmgr.h>

#if defined  __SERIES60_HELP || defined FF_S60_HELPS_IN_USE

#include <hlplch.h>

#include "radio.hlp.hrh"

#endif

#include <akntoolbar.h>

#include <StringLoader.h>

#include <eikmenup.h>

#include <avkon.hrh>

#include <aknlistquerydialog.h> 

#include <AknQueryDialog.h>

#include <AknGlobalNote.h>

#include <fmradio.rsg>

#include <fmradiocommandlineparams.h>

#include <alf/alfenv.h>

#include <AknVolumePopup.h>

#include <fmradiointernalpskeys.h>

#include <fmradiouids.h> 

#include <iaupdate.h>

#include <iaupdateparameters.h>

#include <iaupdateresult.h>

#include <e32property.h>

#include <apgwgnam.h>

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <activeidle2domainpskeys.h>

#include <akntoolbarextension.h>

#include "fmradiobacksteppingservicewrapper.h"

#include "fmradiodocument.h"

#include "fmradioengine.h"

#include "fmradiovariant.hrh"

#include "fmradiomainview.h"

#include "fmradiochannellistview.h"

#include "fmradiocontroleventobserverimpl.h"

#include "fmradioscanlocalstationsview.h"

#include "fmradio.hrh"

#include "fmradioengine.hrh"

#include "fmradioappui.h"

#include "fmradiordsreceiver.h"

#include "fmradioapp.h"

#include "fmradiopubsub.h"

#include "debug.h"

// Application Uid for Active Idle app

#ifdef __ACTIVE_IDLE

const TUid KFMRadioUidIdleApp = { 0x101FD64C };

#else

const TUid KFMRadioUidIdleApp = KPSUidActiveIdle2; // use this one instead because the "aisystemuids.hrh" is not export

#endif

// CONSTANTS 

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

// CFMInformationNote::CFMInformationNote

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

CFMInformationNote::CFMInformationNote( MInformationNoteInterface& aObserver ) :

	CAknInformationNote ( EFalse ),

	iDialogObserver( aObserver )

	{

	}

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

// CFMInformationNote::~CFMInformationNote

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

//

CFMInformationNote::~CFMInformationNote()

	{

	iDialogObserver.DialogTerminated();

	}

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

//

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

// CFMRadioAppUi::ConstructL

// 2nd phase constructor. Instanciates all member objects

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

//

void CFMRadioAppUi::ConstructL()

    {

    FTRACE( FPrint( _L("CFMRadioAppUi::ConstructL()") ) );

    iPendingViewId = TUid::Null();

    iStartUp = ETrue;

    iStartupWizardHandled = EFalse;

    iStartupWizardRunning = EFalse;

    iTuneFromWizardActivated = EFalse;

    iInfoNoteOn = EFalse;

   	BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    iChannels = new( ELeave ) CArrayFixFlat<TChannelInformation>( 1 );

    // initialise local variation key with all features disabled.

    iFMRadioVariationFlags = 0;

    iAudioResourceAvailable = ETrue;

    iAlreadyClean = EFalse;

    iRadioEngine = CRadioEngine::NewL( *this ); // Construct a radio engine object

    // Fill channels array from engine

    GetChannelsArrayL();

    if ( iRadioEngine->IsInCall() ) 

        {

        iCurrentRadioState = EFMRadioStateOffForPhoneCall;

        }

    iBsWrapper = CFMRadioBackSteppingServiceWrapper::NewL( TUid::Uid( KUidFMRadioApplication ) );

    AddViewActivationObserverL( iBsWrapper );    

    iMainView = CFMRadioMainView::NewL( iRadioEngine, *iAlfEnv, *this  );

    AddViewL( iMainView );      // transfer ownership to CAknViewAppUi

    iChannelListView = CFMRadioChannelListView::NewL( iRadioEngine, *this );

    AddViewL( iChannelListView );     // transfer ownership to CAknViewAppUi

    iScanLocalStationsView = CFMRadioScanLocalStationsView::NewL( *iRadioEngine, *this );

    AddViewL( iScanLocalStationsView ); // transfer ownership to CAknViewAppUi

    }

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

// CFMRadioAppUi::SecondaryConstructL()

// All leaving function calls are made here, so that nothing is left on the stack if the ConstructL leaves

// The reason for this behaviour is that the UI framework doesn't handle leaves from the AppUi correctly.

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

//

void CFMRadioAppUi::SecondaryConstructL()

    {

    FTRACE( FPrint( _L("CFMRadioAppUi::SecondaryConstructL()") ) );

	iLayoutChangeObserver = iMainView;

    iRadioEngine->PubSubL().PublishPresetCountL( iChannels->Count() );

    // Create vertical volume popup for speaker and headset

    iIhfVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue );

    iIhfVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel );

    iIhfVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize );

    // Set observer for control events

    iIhfVolumePopupControl->SetObserver( this );

    iHeadsetVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue );

    iHeadsetVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel );

    iHeadsetVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize );

    iHeadsetVolumePopupControl->SetObserver( this );

    iActiveVolumePopupControl = iHeadsetVolumePopupControl; //initialize it to Headset

    // Create and set our observer for control events.

    iControlEventObserver = CFMRadioControlEventObserverImpl::NewL( *this );

    iRadioEngine->PubSubL().SetControlEventObserver( iControlEventObserver );

    // For monitoring side volume key events

    iSvkEvents = CFMRadioSvkEvents::NewL(*this);

	iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationRunning );

	UpdateLandscapeInformation();	

	// Create alfred environment

    iAlfEnv = CAlfEnv::NewL();

	// Create alfred display

	TRect rect;

	AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);	

	if( !IsLandscapeOrientation() )

		{

		TRect toolBarRect = iMainView->Toolbar()->Rect();

		rect.SetHeight( rect.Height() - toolBarRect.Height() );	

		}

	iAlfEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayAsCoeControl );

    }

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

// CFMRadioAppUi::HandleTunerReadyCallback

// Tuner is initialized and ready.

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

//

void CFMRadioAppUi::HandleTunerReadyCallback()

    {        

    iRadioEngine->InitializeRadio();

    }

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

// CFMRadioAppUi::~CFMRadioAppUi

// Destructor

// Frees reserved resources

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

//

CFMRadioAppUi::~CFMRadioAppUi()

    {

    if ( iRadioEngine )

        {

        TRAP_IGNORE(

            iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationClosing ) )

        }

    FTRACE( FPrint( _L("CFMRadioAppUi::~CFMRadioAppUi()") ) );

    if ( iAlreadyClean == EFalse )

        {

        Cleanup();

        }

    if ( iFeatureManagerInitialized )

        {

        FeatureManager::UnInitializeLib();

        }

    }

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

// CFMRadioAppUi::Cleanup()

// Perform object cleanup. This would normally be performed in the destructor,

// but since it can also be called from SecondaryConstructL it was moved into

// a seperate function.

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

//

void CFMRadioAppUi::Cleanup()

    {

    FTRACE( FPrint( _L("CFMRadioAppUi::Cleanup()") ) );

    delete iIhfVolumePopupControl;

    iIhfVolumePopupControl = NULL;

    delete iHeadsetVolumePopupControl;

    iHeadsetVolumePopupControl = NULL;

    if (iRadioEngine)

        {

        delete iRadioEngine;

        iRadioEngine = NULL;

        }

    if (iSvkEvents)

        {

        delete iSvkEvents;

        }

    if (iGlobalOfflineQuery)

        {

        delete iGlobalOfflineQuery;

        }

    if (iLocalActivateOfflineQuery)

        {

        delete iLocalActivateOfflineQuery;

        }

    if (iLocalContinueOfflineQuery)

        {

        delete iLocalContinueOfflineQuery;

        }

    delete iControlEventObserver;

    delete iAlfEnv;

    iAlreadyClean = ETrue;

    if ( iConnectHeadsetGlobalNote )    

    	{

    	delete iConnectHeadsetGlobalNote;

    	iConnectHeadsetGlobalNote = NULL;

    	}

	if ( iConnectHeadsetQuery )

    	{

    	delete iConnectHeadsetQuery;

    	iConnectHeadsetQuery = NULL;	

    	}   

	if ( iChannels )

		{

		iChannels->Reset();

		delete iChannels;

		iChannels = NULL;

		}

	if ( iUpdate )

		{

		delete iUpdate;

		iUpdate = NULL;		

		}

	if ( iParameters )

		{

		delete iParameters;		

		iParameters = NULL;

        }

    if ( iSettingsRepository )

        {

        delete iSettingsRepository;

        iSettingsRepository = NULL;

        }

    if ( iBsWrapper )

        {

        RemoveViewActivationObserver( iBsWrapper );

        }

    delete iBsWrapper;

    iBsWrapper = NULL;

    delete iStartupForegroundCallback;

    iStartupForegroundCallback = NULL;

    }

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

// CFMRadioAppUi::HandleCommandL

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

// accordingly by calling the appropriate command handler

// function for further action.

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

//

void CFMRadioAppUi::HandleCommandL( TInt aCommand )

    {

    FTRACE( FPrint( _L("CFMRadioAppUi::HandleCommandL state=%d command=%d "), iCurrentRadioState, aCommand) );

    if ( iCurrentRadioState == EFMRadioStateOn )

        {

        switch ( aCommand )

            {

            case EFMRadioCmdChannelList:

                ActivateLocalViewL( iChannelListView->Id() );

                break;

            case EFMRadioCmdSeekUp:

                ScanUpL();

                break;

            case EFMRadioCmdSeekDown:

                ScanDownL();

                break;

            case EFMRadioCmdSaveChannel:

            	SaveChannelToLastIntoListL();

                break;

            case EFMRadioCmdScanLocalStations:

            	ActivateLocalViewL(iScanLocalStationsView->Id());

            	break;

            case EFMRadioCmdScanLocalStationsScan:

            	// continue scanning

            	StartLocalStationsSeekL();

        		break;

            case EFMRadioCmdListenCh:

            	if ( iChannels->Count() > 0 )

            		{

                	PlayChannel( iChannelListView->CurrentlySelectedChannel() );

            		}

                break;

            case EFMRadioCmdRename:

                RenameCurrentChannelL();

                break;

            case EFMRadioCmdActivateIhf:

                SetAudioOutput( CRadioEngine::EFMRadioOutputIHF );

                break;

            case EFMRadioCmdDeactivateIhf:

                SetAudioOutput( CRadioEngine::EFMRadioOutputHeadset );

                break;

            case EFMRadioCmdEnableRdsAfSearch:

        		iRadioEngine->SetRdsAfSearchEnable( ETrue );

            	break;

            case EFMRadioCmdDisableRdsAfSearch:

        		iRadioEngine->SetRdsAfSearchEnable( EFalse );

                break;

            case EFMRadioCmdUpdateVolume:

                UpdateVolume( EDirectionNone );

                break;

            case EFMRadioCmdNextChannel:

                {

                TInt channelCount = iChannels->Count();

                if ( channelCount >= 1 )

					{

            		iMainView->SetStationChangeType( EFMRadioStationChangeNext );

	            	PlayChannel( iChannelListView->NextChannel() );

					}

                else

                    {

                    if ( AknLayoutUtils::PenEnabled() )

                        {

                        DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP );

                        }

                    }

                break;

                }

            case EFMRadioCmdPrevChannel:

                {

                TInt channelCount = iChannels->Count();

                if ( channelCount >= 1 )

					{

            		iMainView->SetStationChangeType( EFMRadioStationChangePrevious );

	                PlayChannel( iChannelListView->PreviousChannel() );

					}

                else

                    {

                    if ( AknLayoutUtils::PenEnabled() )

                        {

                        DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP );

                        }

                    }

                break;

            	}

            case EFMRadioCmdMuteOn:

            	iRadioEngine->SetMuteOn( ETrue );

            	break;

            case EFMRadioCmdMuteOff:

            	iRadioEngine->SetMuteOn( EFalse );

            	break;

            case EFMRadioCmdMute:

            	HandleMuteCommand();

            	break;	

            case EAknCmdHelp:

            case EFMRadioCmdHelp:

                {

#if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE

                if ( ActiveView() == KFMRadioMainViewId )

                	{	

                	HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), GetCurrentHelpContextL() );

                	}

                else

                	{

                    CArrayFix<TCoeHelpContext>* buf = CCoeAppUi::AppHelpContextL();

                    HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), buf );

                	}

#endif

                }

                break;

            case EFMRadioCmdScanLocalStationsViewActive:

            	iLayoutChangeObserver = iScanLocalStationsView;

            	break;

            case EFMRadioCmdChannelListViewActive:

                iLayoutChangeObserver = iChannelListView;

                break;

            case EFMRadioCmdMainViewActive:

                iLayoutChangeObserver = iMainView;

            if ( iAutoTune &&

               ( iScanLocalStationsView->CancelType() == EFMRadioCancelScanBySoftkey ||

                 iScanLocalStationsView->CancelType() == EFMRadioCancelScanDefault))

           		{

            	ScanUpL();

            	iAutoTune = EFalse;

            	iAutoTuneUnmute = ETrue;

            	}

                break;

            default:

                break;

            }

        }

    else if( iCurrentRadioState == EFMRadioStateBusyScanUp ||

             iCurrentRadioState == EFMRadioStateBusyScanDown ||

             iCurrentRadioState == EFMRadioStateBusySeek ||

             iCurrentRadioState == EFMRadioStateBusyScanLocalStations )

        {

        switch ( aCommand )

            {

            case EFMRadioCmdStopTuning:

            case EAknSoftkeyCancel:

                CancelSeek();

                break;

            default:

                break;

            }

        }

    switch ( aCommand )

        {

        case EAknSoftkeyExit:

        case EEikCmdExit:

        case EAknCmdExit:

            Exit();

            break;

        default:

            break;

        }

    }

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

// CFMRadioAppUi::ActiveView

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

//

TUid CFMRadioAppUi::ActiveView() const

    {

    return iView ? iView->Id() : KNullUid;

    }

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

// CFMRadioAppUi::RadioEngine

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

//

CRadioEngine* CFMRadioAppUi::RadioEngine()

	{

	return iRadioEngine;

	}

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

// CFMRadioAppUi::Document

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

//

CFMRadioDocument* CFMRadioAppUi::Document() const

    {

    return static_cast<CFMRadioDocument*>( CEikAppUi::Document() );

    }

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

// CFMRadioAppUi::BackSteppingWrapper

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

//

CFMRadioBackSteppingServiceWrapper& CFMRadioAppUi::BackSteppingWrapper() const

    {

    return *iBsWrapper;

    }

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