/*

* Copyright (c) 2004 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:  Container class for IRHistoryListContainer

*

*/

/* ---------------------------------------------------------------------------

*  Version history:

*  Template version:

*  <ccm_history>

*

*  Version: 2, Thu Apr 10 20:00:00 2008 by Rohit

*  Ref:

*  Implemented SongHistory changes for channelwise songs

*

*  </ccm_history>

* ============================================================================

*/

#include <stringloader.h>

#include <internetradio.rsg>

#include "iraap.hlp.hrh"

#include <aknsinglestyletreelist.h>

#include <aknsbasicbackgroundcontrolcontext.h>

#include <akntoolbar.h>

#include "irsonghistoryengine.h"

#include "irui.h"

#include "ir.hrh"

#include "ircommon.h"

#include "irdebug.h"

#include "irbaseview.h"

#include "irhistorylistview.h"

#include "irhistorylistcontainer.h"

#include "irapplication.h"

#include "irsonghistoryinfo.h"

#include "irnowplayingwrapper.h"

#include "irfavoritesdb.h"

#include "irisdswrapper.h"

#include "irisdspreset.h"

#include "irpubsub.h"

const TInt KMaxSize = 5;

const TInt KTwo = 2 ;

_LIT(KNo,"No");

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

//  CIRHistoryListContainer::NewL

//  Creates a new instance of History Container

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

//

CIRHistoryListContainer* CIRHistoryListContainer::NewL(

			const TRect& aRect,CIRHistoryListView& aView,

			RPointerArray<CIRSongHistoryInfo>& aHistoryDataArr)

    {

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

    CIRHistoryListContainer* self = CIRHistoryListContainer::NewLC(aRect,aView,aHistoryDataArr);

    CleanupStack::Pop(self);

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

    return self;

    }

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

//  CIRHistoryListContainer::NewLC

//  Creates a new instance of History Container and leaves it on the cleanup stack.

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

//

CIRHistoryListContainer* CIRHistoryListContainer::NewLC(const TRect& aRect ,

			CIRHistoryListView& aView ,RPointerArray<CIRSongHistoryInfo>& aHistoryDataArr)

    {

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

    CIRHistoryListContainer* self = new (ELeave) CIRHistoryListContainer(aView);

    CleanupStack::PushL(self);

    self->ConstructL(aRect,aHistoryDataArr);

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

    return self;

    }

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

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

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

//

CIRHistoryListContainer::CIRHistoryListContainer( CIRHistoryListView& aHistoryListView):

                                                  iHistoryListView( aHistoryListView )

    {

    IRLOG_DEBUG( "CIRHistoryListContainer::CIRHistoryListContainer" );

    iDimmed=ETrue;

    }

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

// CIRHistoryListContainer::ConstructL

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

//

void CIRHistoryListContainer::ConstructL( const TRect& aRect, 

						RPointerArray<CIRSongHistoryInfo>& aHistoryDataArr

						 )

    {

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

   CreateWindowL();

   InitComponentArrayL();

   Components().SetControlsOwnedExternally( ETrue );

   CAknSingleStyleTreeList* list =CAknSingleStyleTreeList::NewL( *this );

    // Use list as a component control of the view.

    Components().AppendLC( list, KCoeNoControlId );

    CleanupStack::Pop( list );

    iTreeListBox = list;

    iTreeListBox->SetContainerWindowL(*this);

    iTreeListBox->SetFlags( iTreeListBox->Flags() ^ KAknTreeListLooping ^ 

                            KAknTreeListNoStructureLines ^ KAknTreeListMarqueeScrolling);

    iTreeListBox->AddObserverL( this );

    iBgContext = CAknsBasicBackgroundControlContext::NewL(

        KAknsIIDQsnBgAreaMain, iAvkonAppUi->ApplicationRect(), EFalse );

	iChannelArray=new ( ELeave ) CDesC16ArrayFlat (KMaxSize);

	iUrlArray=new ( ELeave ) CDesC16ArrayFlat (KMaxSize);

	iChannelDescriptionArray=new ( ELeave ) CDesC16ArrayFlat (KMaxSize);

	iMusicStoreStatus=new ( ELeave ) CDesC16ArrayFlat (KMaxSize);

    UpdateAllL(aHistoryDataArr);

    iTreeListBox->SetRect(aRect);

	iTreeListBox->SetFocus(ETrue);

    iTreeListBox->MakeVisible(ETrue);

    SetRect( aRect );

    DrawNow();

    iTreeListBox->DrawNow();

    IRLOG_DEBUG( "CIRHistoryListContainer::ConstructL - Exiting" );

    }

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

// Destructor

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

//

CIRHistoryListContainer::~CIRHistoryListContainer()

    {

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

        if(iTreeListBox)

    	{

    	delete iTreeListBox;

    	iTreeListBox = NULL;

    	}

    	iNodeArray.Close();

    	iLeafArray.Close();

    	iChannelTypeArray.Close();

    	iChannelIdArray.Close();

    	if(iBgContext)

	    	{

	    	delete iBgContext;

	    	iBgContext = NULL;	

	    	}

    	if(iUrlArray)

	    	{

	    	iUrlArray->Reset();

	    	delete iUrlArray;	

	    	iUrlArray=NULL;

	    	}

    	if(iChannelArray)

	    	{

	    	iChannelArray->Reset();

	    	delete iChannelArray;

	    	iChannelArray=NULL;	

	    	}

    	if(iChannelDescriptionArray)

	    	{

	    	iChannelDescriptionArray->Reset();

	    	delete iChannelDescriptionArray;	

	    	iChannelDescriptionArray=NULL;

	    	}

    	if(iMusicStoreStatus)

	    	{

	    	iMusicStoreStatus->Reset();

	    	delete iMusicStoreStatus;	

	    	iMusicStoreStatus=NULL;

	    	}

        IRLOG_DEBUG( "CIRHistoryListContainer::~CIRHistoryListContainer - Exiting" );

    }

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

// From class CCoeControl.

// We need to catch the selection key event in order to do a couple of things 

// in moving state make the movement, and in normal state open channel 

// specific popup menu. Up and down buttons are forwarded to the list.

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

//

TKeyResponse CIRHistoryListContainer::OfferKeyEventL( 

        const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    IRLOG_DEBUG( "CIRHistoryListContainer::OfferKeyEventL -Entering" );

    if(iTreeListBox)

	    {

        IRLOG_DEBUG( "CIRHistoryListContainer::OfferKeyEventL -Exiting" );

	    return iTreeListBox->OfferKeyEventL(aKeyEvent, aType);

	    }

	return EKeyWasNotConsumed;   

    }

void CIRHistoryListContainer::HandlePointerEventL( const TPointerEvent& aPointerEvent )

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::HandlePointerEventL - Entering" );

	if(iTreeListBox)

		{

		iTreeListBox->HandlePointerEventL( aPointerEvent ); 

		}

	IRLOG_DEBUG( "CIRHistoryListContainer::HandlePointerEventL - Exiting" );

	}

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

// CIRHistoryListContainer::UpdateAllL()

// Fills list with  data read from data base.

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

//

void CIRHistoryListContainer::UpdateAllL(RPointerArray<CIRSongHistoryInfo> & aHistoryDataArr)

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::UpdateAllL - Entering" );

	if(aHistoryDataArr.Count()==0)

		{

        iTreeListBox->DrawNow();

	    HBufC* headerText = StringLoader::LoadLC(R_IRAPP_CLEAR_HISTORY);

		iTreeListBox->SetEmptyTextL(*headerText);

		CleanupStack::PopAndDestroy(headerText); 

		}

	else

		{

        TUint32 flags = CAknSingleStyleTreeList::EPersistent;

		TBool drawNow = EFalse;

		for(TInt songCount = 0; songCount < aHistoryDataArr.Count(); songCount++)  

			{

			if(songCount==0)     

				{

				iChannelArray->AppendL(aHistoryDataArr[songCount]->GetChannelName());

			    iUrlArray->AppendL(aHistoryDataArr[songCount]->GetStreamUrl());

                iChannelTypeArray.Append(aHistoryDataArr[songCount]->GetChannelType());

                iChannelIdArray.Append(aHistoryDataArr[songCount]->GetChannelId());

                iChannelDescriptionArray->AppendL(aHistoryDataArr[songCount]->GetChannelDesc()); 

                iMusicStoreStatus->AppendL(aHistoryDataArr[songCount]->GetChannelMusicStatus());	

                }

			else

				{

				TBool nextChannel=EFalse;

				for(TInt comp=0;comp<iChannelArray->Count();comp++)

					{

					if((aHistoryDataArr[songCount]->GetChannelName()==iChannelArray->MdcaPoint(comp)) &&

					         (aHistoryDataArr[songCount]->GetStreamUrl()==iUrlArray->MdcaPoint(comp)) &&

					         (aHistoryDataArr[songCount]->GetChannelType()==iChannelTypeArray[comp]))

						{

						nextChannel=ETrue;	

						}

					}

					if(!nextChannel)

							{

							iChannelArray->AppendL(aHistoryDataArr[songCount]->GetChannelName());

						    iUrlArray->AppendL(aHistoryDataArr[songCount]->GetStreamUrl());

		                    iChannelTypeArray.Append(aHistoryDataArr[songCount]->GetChannelType());

		                    iChannelIdArray.Append(aHistoryDataArr[songCount]->GetChannelId());

		                    iChannelDescriptionArray->AppendL(aHistoryDataArr[songCount]->

		                                                      GetChannelDesc()); 

		                    iMusicStoreStatus->AppendL(aHistoryDataArr[songCount]->

		                                                      GetChannelMusicStatus());	

							}

				}

			}

		for(TInt index=0;index<iChannelArray->Count();index++) 

			{

			TAknTreeItemID subtitle = iTreeListBox->AddNodeL( 1,

			                                                 iChannelArray->MdcaPoint(index), 

			                                                 flags,

			                                                 drawNow );

			iNodeArray.Append(subtitle);	

			}

		for(TInt songCount = 0; songCount < aHistoryDataArr.Count(); songCount++)            

			{

			for(TInt index=0;index<iChannelArray->Count();index++)

				{

					if((aHistoryDataArr[songCount]->GetChannelName()==iChannelArray->MdcaPoint(index)) &&

					         (aHistoryDataArr[songCount]->GetStreamUrl()==iUrlArray->MdcaPoint(index)) &&

					         (aHistoryDataArr[songCount]->GetChannelType()==iChannelTypeArray[index]))

						{

				        HBufC* text ;

						CDesCArray* strings = new ( ELeave ) CDesCArrayFlat( 2 );

						CleanupStack::PushL( strings );

				        if(aHistoryDataArr[songCount]->GetArtistInfo() != KNullDesC &&

				           aHistoryDataArr[songCount]->GetSongInfo() != KNullDesC)

					        {

							strings->AppendL(aHistoryDataArr[songCount]->GetArtistInfo());

							strings->AppendL(aHistoryDataArr[songCount]->GetSongInfo());

						    text = StringLoader::LoadLC( R_IR_HISTORY_ARTIST_SONG, *strings );

					        }

                        else if(aHistoryDataArr[songCount]->GetArtistInfo() != KNullDesC)

					        {

	                     	text = HBufC::NewLC( aHistoryDataArr[songCount]->

	                     						GetArtistInfo().Length() + KTwo );

	                     	text->Des().Copy(aHistoryDataArr[songCount]->GetArtistInfo());

					        }

				        else

					        {

	                     	text = HBufC::NewLC( aHistoryDataArr[songCount]->

	                     						GetSongInfo().Length() + KTwo );

	                     	text->Des().Copy(aHistoryDataArr[songCount]->GetSongInfo());

					        }

						if(index>=0 && index<iNodeArray.Count())

							{

							TAknTreeItemID coreItem = iTreeListBox->AddLeafL( iNodeArray[index],

							*text, flags, drawNow );

							iTreeListBox->SetIcon( coreItem, CAknSingleStyleTreeList::ELeaf, NULL, ETrue );

							iLeafArray.AppendL(coreItem);   	

							}

						CleanupStack::PopAndDestroy( text );	

                        CleanupStack::PopAndDestroy( strings );

						}

				}

			}

		iTreeListBox->DrawNow();

		if(iHistoryListView.Toolbar())

			{

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

            iHistoryListView.Toolbar()->DrawNow();

          	}

		}	

	IRLOG_DEBUG( "CIRHistoryListContainer::UpdateAllL - Exiting" );

	}

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

// CIRHistoryListContainer::RemoveListItem() 

// Removes  data  from the list read from data base.

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

//

void CIRHistoryListContainer::RemoveListItem(const TDesC &/*aSongName*/ , const TDesC & /*aArtistName*/, const TDesC & /*aChannelName*/)

{

IRLOG_DEBUG( "CIRHistoryListContainer::RemoveListItem" );	 

}

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

// From class CCoeControl.

// Draws the control.

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

//

void CIRHistoryListContainer::Draw( const TRect& /*aRect*/ ) const

    {

    IRLOG_DEBUG( "CIRHistoryListContainer::Draw" );

    }

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

// From class CCoeControl.

// Opens help by context.

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

//

void CIRHistoryListContainer::GetHelpContext( TCoeHelpContext& aContext ) const

    {

    IRLOG_DEBUG( "CIRHistoryListContainer::GetHelpContext - Entering" );

    aContext = TCoeHelpContext( KIRMCVUid, KIR_HELP_STATIONS  );

    IRLOG_DEBUG( "CIRHistoryListContainer::GetHelpContext - Exiting" );

    }

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

// CIRHistoryListContainer::ClearHistoryListL().

// Clears the List

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

//

void CIRHistoryListContainer::ClearHistoryListL()

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::ClearHistoryListL - Entering" );

	HBufC* headerText = StringLoader::LoadLC(R_IRAPP_CLEAR_HISTORY);

	iTreeListBox->SetEmptyTextL(* headerText);

	CleanupStack::PopAndDestroy(headerText); 

	for(TInt index=0;index<iNodeArray.Count();index++)

		{

		iTreeListBox->RemoveItem( iNodeArray[index], EFalse );

		}

	iNodeArray.Reset();

	iLeafArray.Reset();

	iChannelTypeArray.Reset();

	iChannelIdArray.Reset();

	if(iUrlArray)

		{

		iUrlArray->Reset();

		}

	if(iMusicStoreStatus)

		{

		iMusicStoreStatus->Reset();

		}

	if(iChannelArray)

		{

		iChannelArray->Reset();

		}

	if(iChannelDescriptionArray)

	{

	iChannelDescriptionArray->Reset();

	}

	IRLOG_DEBUG( "CIRHistoryListContainer::ClearHistoryListL - Exiting" );

	}

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

// CIRHistoryListContainer::ListenUrlL()

// Listen a URL and displays Now Playing

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

//

void CIRHistoryListContainer::ListenUrlL( TInt aIndex )

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::ListenUrlL - Entering" );

	iHistoryListView.iNowPlayingWrapper->SetView(EHistoryView);

	iListenFrmHistory = ETrue ;

    iAddFrmHistory = EFalse;

	// Listen the URL

	if(aIndex>=0 && aIndex<iChannelTypeArray.Count())

		{

		if(iChannelTypeArray[aIndex]==0)

			{

			CIRIsdsPreset* preset = CIRIsdsPreset::NewL();

			CleanupStack::PushL( preset );

			preset->SetName(iChannelArray->MdcaPoint(aIndex));

			if(aIndex>=0 && aIndex<iChannelTypeArray.Count())

				{

				preset->SetChannelType(iChannelTypeArray[aIndex]);

				}

			preset->SetShortDesc(iChannelDescriptionArray->MdcaPoint(aIndex ));

	        preset->SetDescription(iChannelDescriptionArray->MdcaPoint(aIndex ));

			//Set the URL data.

			_LIT(KNA,"NA");

			preset->SetUrlL( KNA, iUrlArray->MdcaPoint(aIndex ), 0 );

			preset->SetUrlCount();

			// Set the channel as last played and currently playing

			*iHistoryListView.iNowPlayingWrapper->iNowPlayingPreset = *preset;

			CleanupStack::PopAndDestroy( preset );

			iHistoryListView.iUi->iNPPrevViewId = KIRHistoryListViewId;

			//connecting to server	

			iHistoryListView.iNowPlayingWrapper->SetCurrentConnectionSource(EIRHistoryAdhoc);

			iHistoryListView.iNowPlayingWrapper->ConnectToChannelL(*iHistoryListView.

			                                 iNowPlayingWrapper->iNowPlayingPreset);

			}

		else

			{

			iHistoryListView.iUi->iNPPrevViewId = KIRHistoryListViewId;

			if(aIndex>=0 && aIndex<iChannelIdArray.Count())

				{

				iChannelSyncId = iChannelIdArray[aIndex] ;

				iChangedIndex = aIndex;

				iHistoryListView.iNowPlayingWrapper->SetWhenUserCancelsBufferingWaitBar(EFalse);

		 		iHistoryListView.iNowPlayingWrapper->SetListenFromIsdsValue(EFalse);

		    	iHistoryListView.iNowPlayingWrapper->CreateWaitDialogL();

	    		iHistoryListView.iUi->GetPubSubManagerInstance()->PublishBufferingState(

	    								EIRStateBufferingStart);

				iHistoryListView.iIsdsWrapper->IsdsListenRequestL(this,iChannelIdArray[aIndex],ETrue);

				}

			}

		}

	IRLOG_DEBUG( "CIRHistoryListContainer::ListenUrlL - Exiting" );

    }

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

// void CIRHistoryListContainer::SizeChanged(const TRect& aRect)

// 

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

//

void CIRHistoryListContainer::SizeChanged()

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::SizeChanged - Entering" );

    TRect rect = Rect();

    if (iTreeListBox)

        {

        iTreeListBox->SetRect( rect );

        }

    if ( iBgContext )

        {

        iBgContext->SetRect( rect );

        }

    IRLOG_DEBUG( "CIRHistoryListContainer::SizeChanged - Exiting" );

	}

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

// CIRHistoryListContainer::CountComponentControls() const

// returns the number of components in the view.

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

//

TInt CIRHistoryListContainer::CountComponentControls() const

	{

	IRLOG_DEBUG( "CIRHistoryListContainer::CountComponentControls" );

	return 1;

	}

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

// CIRHistoryListContainer::ComponentControl() const

// returns a pointer to the control under this view depending on the index

// passed,to the framework.

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