/*

* 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 =======================

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CFMRadioAppUi::CFMRadioAppUi() :

    iStartUp( ETrue ),

    iStartupWizardHandled( EFalse ),

    iStartupWizardRunning( EFalse ),

    iTuneFromWizardActivated( EFalse ),

    iInfoNoteOn( EFalse ),

    iPendingViewId( KNullUid ),

    iRegionChanged( EFalse )

    {

    }

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

// CFMRadioAppUi::ConstructL

// 2nd phase constructor. Instanciates all member objects

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

//

void CFMRadioAppUi::ConstructL()

    {

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

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    FeatureManager::InitializeLibL();

    iFeatureManagerInitialized = ETrue;

    // 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;

        }

     iChannels.ResetAndDestroy();

     iChannels.Close();

    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;

            default:

                break;

            }

        }

    else if ( iCurrentRadioState == EFMRadioStateBusySeek ||

             iCurrentRadioState == EFMRadioStateBusyScanLocalStations )

        {

        switch ( aCommand )

            {

            case EFMRadioCmdStopTuning:

            case EAknSoftkeyCancel:

                CancelSeek();

                break;

            default:

                break;

            }

        }

    switch ( aCommand )

        {

        case EFMRadioCmdScanLocalStationsViewActive:

            iLayoutChangeObserver = iScanLocalStationsView;

            break;

        case EFMRadioCmdChannelListViewActive:

            iLayoutChangeObserver = iChannelListView;

            break;

        case EFMRadioCmdMainViewActive:

            iLayoutChangeObserver = iMainView;

            break;

        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;

    }

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

// CFMRadioAppUi::TurnRadioOn

// Turn the fm radio hardware on

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

//

void CFMRadioAppUi::TurnRadioOn()

    {

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

    if ( !iRadioEngine->IsRadioOn() )

        {