/*

* Copyright (c) 2006-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:  view class for pls list

*

*/

#include <hlplch.h>

#include <internetradio.rsg>

#include <internetradio.mbg>

#include "ir.hrh"

#include "ircommon.h"

#include "irdebug.h"

#include "irplsview.h"

#include "irplscontainer.h"

#include "irui.h"

#include "irbaseview.h"

#include "irsettings.h"

#include "irnowplayingwrapper.h"

#include "irisdspreset.h"

#include <eikclbd.h>

#include <akntoolbar.h>

#include "irnetworkcontroller.h" 	

#include "iractivenetworkobserver.h"

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

//  CIRPlsView::NewL

//  Creates a new instance of pls view

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

//

CIRPlsView* CIRPlsView::NewL(const TRect& aRect)

    {

	IRLOG_DEBUG( "CIRPlsView::NewL - Entering" );

    CIRPlsView* self = CIRPlsView::NewLC(aRect);

    CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRPlsView::NewL - Exiting." );

    return self;

    }

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

//  CIRPlsView::NewLC

//  Creates a new instance of pls view and leaves it on the cleanup stack.

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

//

CIRPlsView* CIRPlsView::NewLC(const TRect& aRect)

    {

    IRLOG_DEBUG( "CIRPlsView::NewLC - Entering" );

    CIRPlsView* self = new (ELeave) CIRPlsView;

    CleanupStack::PushL(self);

    self->ConstructL(aRect);

	IRLOG_DEBUG( "CIRPlsView::NewLC - Exiting." );

    return self;

    }

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

//  CIRPlsView::CIRPlsView()

//  Default constructor

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

//

CIRPlsView::CIRPlsView():iContainer(NULL) 

    {

	IRLOG_DEBUG( "CIRPlsView::CIRPlsView" );

	SetCurrentTopItem(0);

    }

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

//  CIRPlsView::~CIRPlsView()

//  Destructor

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

//

CIRPlsView::~CIRPlsView()

    {

	IRLOG_DEBUG( "CIRPlsView::~CIRPlsView - Entering" );

    if ( iContainer )

        {

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

        delete iContainer;

    	}

	if( AknLayoutUtils::PenEnabled() && Toolbar() )

		{

		Toolbar()->SetToolbarVisibility(EFalse, EFalse);

		Toolbar()->SetToolbarObserver( NULL );

		}

	IRLOG_DEBUG( "CIRPlsView::~CIRPlsView - Exiting." );

    }

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

//  CIRPlsView::ConstructL

//  Second phase constructor

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

//

void CIRPlsView::ConstructL(const TRect& /*aRect*/)

	{

	IRLOG_DEBUG( "CIRPlsView::ConstructL - Entering" );

    CIRBaseView::ConstructL(R_IR_PLSVIEW);

	MAknsSkinInstance * skin=AknsUtils::SkinInstance () ;

    TRgb color;

    TInt skinColor=AknsUtils::GetCachedColor(skin, color, KAknsIIDQsnTextColors,

    				                                      EAknsCIQsnTextColorsCG6 );

	if(color.Gray2()!=0)

		{

		CreateAndSetToolbarL(R_NOW_PLSLIST_WHITE_TOOLBAR);

		}

	else

		{

		CreateAndSetToolbarL(R_NOW_PLSLIST_BLACK_TOOLBAR);	

		}

	if( AknLayoutUtils::PenEnabled() && Toolbar() )

		{

		Toolbar()->SetToolbarObserver( this );

		}

	SetCurrentFocus(0);

	iRequestPending = EFalse;

	IRLOG_DEBUG( "CIRPlsView::ConstructL - Exiting." );

	}

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

//  TUid CIRPlsView::Id()

//  This returns the view ID

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

//

TUid CIRPlsView::Id() const

    {

    IRLOG_DEBUG( "CIRPlsView::Id" );

    return KIRPlsViewID;

    }

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

//  This is called when a view needs to be activated. 

//  This creates container with its controls.

//  It also receives messages sent to the view.

//  aPrevViewId is passed s.t. we can return to the previous view.

//  aCustomMessageId is an ID for the message.

//  aCustomMessage is the actual message.

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

//

void CIRPlsView::DoActivateL(const TVwsViewId& aPrevViewId,TUid /*aCustomMessageId*/,

   const TDesC8& aCustomMessage)

	{

	IRLOG_DEBUG( "CIRPlsView::DoActivateL - Entering" );

	iUi->iPresentViewID = KIRPlsViewID;

    if ( !iContainer )

		{

		iContainer =CIRPlsContainer::NewL(ClientRect(),*this);

		iContainer->SetMopParent( this );

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

		}

    else

       {

	    // we must notify a resource change in order to update the skin context

	    // This is a flaw of CEikFormattedCellListBox

		iContainer->SetRect(ClientRect());

    	iContainer->HandleResourceChange(KEikDynamicLayoutVariantSwitch);

       }

	ConstructToolbarL();

    iContainer->ActivateL();

    iContainer->MakeVisible( ETrue );

    SetTitleL( R_IRAPP_FEATURE_FILE_TITLE );

    CIRBaseView::DoActivateL( aPrevViewId, TUid::Uid(1), aCustomMessage );

    HandleStatusPaneSizeChange();

    iUi->iNetworkController->RegisterActiveNetworkObserverL(*this);

    IRLOG_DEBUG( "CIRPlsView::DoActivateL - Exiting" );

	}

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

// CIRPlsView::DoDeactivate()

// This is called when a view needs to be deactivated. 

// This destroys container with its controls.

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

//

void CIRPlsView::DoDeactivate()

	{

	IRLOG_DEBUG( "CIRPlsView::DoDeactivate - Entering" );

	if ( iContainer )

		{

	    SetCurrentFocus(iContainer->GetCurrentItemIndex());

		SetCurrentTopItem(iContainer->GetListBoxTopIndex());

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

        delete iContainer;

 		iContainer = NULL;

		}

	if( AknLayoutUtils::PenEnabled() && Toolbar() )

		{

		Toolbar()->SetToolbarVisibility(EFalse, EFalse);

		Toolbar()->SetToolbarObserver( NULL );

		}

    iUi->iNetworkController->DeleteActiveNetworkObserver(*this);

	IRLOG_DEBUG( "CIRPlsView::DoDeactivate - Exiting." );

	}

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

//  CIRPlsView::HandleCommandL(TInt aCommand) 

//  Command handling function

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

//	

void CIRPlsView::HandleCommandL(TInt aCommand)

	{

	IRLOG_DEBUG( "CIRPlsView::HandleCommandL - Entering" );

	iCurrentFocus = iContainer->GetCurrentItemIndex();	

    // handle the corresponding command selected by the user through options.

	switch(aCommand)

		{

		case EListenCmd:

			{

			iUi->SetListenFromPls(ETrue);

			if( iUi->VerifyNetworkConnectivityL() )

				{

				iRequestPending = ETrue;

				break;

				}

			else

				{

				SetCurrentFocus(iContainer->GetCurrentItemIndex());

				iContainer->ListenToStationL(); 

				}

     		}

		    break;

		case ESaveCmd:

			{  

			if( !iUi->CheckAndNotifyLowDiskSpaceL() )

				{

     			iContainer->SaveL();

				}

			}	

			break;

		case ESaveAllCmd:

			{

			if( !iUi->CheckAndNotifyLowDiskSpaceL() )

				{

				iContainer->SaveAllL();

				}

		 	}

			break;

		case EGotoNowPlayingViewCmd:

		    {

		    SetCurrentFocus(iContainer->GetCurrentItemIndex());

			iUi->SetHistory(EFalse);

			iUi->SavePrevIDL(KIRMainChoiceViewID,aCommand); 

		    }

		    break;

		case ESettingsCmd:

		    {

		    SetCurrentFocus(iContainer->GetCurrentItemIndex());

		    AppUi()->ActivateLocalViewL(KIRSettingsViewId);

		    }

		    break;

	    case EHelpCmd:

			{

			if( !iUi->CheckAndNotifyLowDiskSpaceL() )

				{

				SetCurrentFocus(iContainer->GetCurrentItemIndex());

	            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),

	            			 AppUi()->AppHelpContextL() );

				}

			}

            break;

		case EGotoMainView:

			{

			_LIT8(KNull,"");

			AppUi()->ActivateLocalViewL( KIRMainChoiceViewID ,KMainViewLaunch ,KNull);

			}

	    	break;   

		default:

			{

			CIRBaseView::HandleCommandL( EAknSoftkeyExit );	

			}

		}

	IRLOG_DEBUG( "CIRPlsView::HandleCommandL - Exiting." );

	}

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

// CIRPlsView::DynInitMenuPaneL()

// Dynamically handles menu pane.

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

//

void CIRPlsView::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)

	{

	IRLOG_DEBUG( "CIRPlsView::DynInitMenuPaneL - Entering" );

	// Pls view options menu  

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

	if(aResourceId == R_IR_MENU_PLS  )

		{

        	if(!aMenuPane) User::Leave(KErrNotFound);

        	{   

				// Now Playing option

				if(iNowPlayingWrapper->iPlaying)

					{

					 aMenuPane->SetItemDimmed(EGotoNowPlayingViewCmd,EFalse);

					}

				else

					{

					 aMenuPane->SetItemDimmed(EGotoNowPlayingViewCmd,ETrue);

					}

				if(iUi->IsFirstTime())

					{

					aMenuPane->SetItemDimmed(EGotoMainView,ETrue);	

					}

				else

					{

					aMenuPane->SetItemDimmed(EGotoMainView,EFalse);	

					}

        	}

		}

	IRLOG_DEBUG( "CIRPlsView::DynInitMenuPaneL - Exiting." );

	}

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

// CIRPlsView::ConstructToolbarL()

// Coonstructs the toolbar for the view.

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

//    

void CIRPlsView::ConstructToolbarL()

	{

	IRLOG_DEBUG( "CIRPlsView::ConstructToolbarL - Entering." );

	TInt count = (iUi->iURLs.Count());

    if(Toolbar())

	    {

		if((count==0))

			{

			Toolbar()->SetItemDimmed(ESaveCmd,ETrue,ETrue);

			Toolbar()->SetItemDimmed(EListenCmd,ETrue,ETrue);

			}

		else

			{

			Toolbar()->SetItemDimmed(ESaveCmd,EFalse,ETrue);

			Toolbar()->SetItemDimmed(EListenCmd,EFalse,ETrue);

			}

		if((count<=2))

			{

			Toolbar()->SetItemDimmed(ESaveAllCmd,ETrue,ETrue);

			}

		else

			{

			Toolbar()->SetItemDimmed(ESaveAllCmd,EFalse,ETrue);

			}

		Toolbar()->SetToolbarVisibility( ETrue );

	    // Update rect, as changes in toolbar visibility also affect layout.

	    if(iContainer)

		    {

		    iContainer->SetRect( ClientRect() );

		    iContainer->DrawDeferred();

		    }

	    }

	IRLOG_DEBUG( "CIRPlsView::ConstructToolbarL - Exiting." );

	}

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

// CIRPlsView::ConstructToolbarL()

// Dynamically initialises a tool bar..

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

//    

void CIRPlsView::DynInitToolbarL( TInt /*aResourceId*/, CAknToolbar* /*aToolbar*/ )

	{

	IRLOG_DEBUG( "CIRPlsView::DynInitToolbarL - Entering." );

	IRLOG_DEBUG( "CIRPlsView::DynInitToolbarL - Exiting." );

    }

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

// CIRMainView::OfferToolbarEventL()

// catch the selection key event and perform the operation according to it...

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

void CIRPlsView::OfferToolbarEventL

        ( TInt aCommand )

	{

	IRLOG_DEBUG( "CIRPlsView::OfferToolbarEventL - Entering." );

	HandleCommandL(aCommand);

	IRLOG_DEBUG( "CIRPlsView::OfferToolbarEventL - Exiting." );

	}

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

// CIRPlsView::HandleStatusPaneSizeChange()

// 

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

//	

void CIRPlsView::HandleStatusPaneSizeChange()

    {

    IRLOG_DEBUG( "CIRPlsView::HandleStatusPaneSizeChange - Entering." );

    // the client rect is also set here after screen orientation change

    if (iContainer )

        {

        iContainer->SetRect( ClientRect() );

        }

    IRLOG_DEBUG( "CIRPlsView::HandleStatusPaneSizeChange - Exiting." );

    }

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

// From class CAknView.

// Foreground event handling function.

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

//

void CIRPlsView::HandleForegroundEventL( TBool aForeground )

	{

	IRLOG_DEBUG( "CIRMainView::HandleForegroundEventL - Entering" );

	CIRBaseView::HandleForegroundEventL( aForeground );

	if(aForeground)

	{

	if(iContainer)

		{

		MAknsSkinInstance * skin=AknsUtils::SkinInstance () ;

	    TRgb color;

	    TInt skinColor=AknsUtils::GetCachedColor(skin, color, KAknsIIDQsnTextColors,

	    				                                      EAknsCIQsnTextColorsCG6 );

		if(color.Gray2()!=0)

			{

			CreateAndSetToolbarL(R_NOW_PLSLIST_WHITE_TOOLBAR);

			}

		else

			{

			CreateAndSetToolbarL(R_NOW_PLSLIST_BLACK_TOOLBAR);	

			}

        if( AknLayoutUtils::PenEnabled() && Toolbar() )

			{

			Toolbar()->SetToolbarObserver( this );

			}

		ConstructToolbarL();

	    //iUi->iNetworkController->RegisterActiveNetworkObserver(this)

	    //iListen = ETrue

	    iContainer->DrawDeferred();

        Toolbar()->DrawDeferred();

		iContainer->SecondPls();

		}

	}

	IRLOG_DEBUG( "CIRMainView::HandleForegroundEventL - Exiting." );

	}		

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

//Notifies all observers whose network request is active

// to reissue the request  

//NotifyActiveNetworkObserversL()

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

void CIRPlsView::NotifyActiveNetworkObserversL(TIRNetworkEvent aEvent)

	{

	IRLOG_DEBUG( "CIRPlsView::NotifyActiveNetworkObserversL - Entering." );

	switch(aEvent)

	{

	case ENetworkConnectionDisconnected:

		{

		iNowPlayingWrapper->HandleNetworkDisconnected();

		}

		break;

	case ENetworkConnectionEstablished:

		{

		if(iContainer)

			{

			if(iRequestPending || iUi->iNetworkController->IsHandingOverConnection())

				{

				SetCurrentFocus(iContainer->GetCurrentItemIndex());

				iContainer->ListenToStationL(); 

				}

			}

		ResetPendingRequests(EFalse);

		}

	}

	IRLOG_DEBUG( "CIRPlsView::NotifyActiveNetworkObserversL - Exiting." );

	}

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

// Notified by network controller when user cancels network connection, to reset 

// the pending requests  

// ResetPendingRequests()

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

void CIRPlsView::ResetPendingRequests(TBool aValue)

	{

	iRequestPending = aValue;

	}

// CIRPlsView :: SecondConstruct()

// To again initialise when Second pls file is opened.

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

//

void CIRPlsView::SecondConstruct()

	{

	SetCurrentFocus(0);

	SetCurrentTopItem(0);

	iRequestPending = EFalse;

	}