/*

* 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:  ?Description

*

*/

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

*  Version history:

*  Template version:

*  <ccm_history>

*

*  Version: 19, Fri Sep 19 13:00:00 2008 by Rohit

*  Ref:

*  Added ASF detection and Integrated CIRAsfPlayer in Now Playing scenario

*

*  </ccm_history>

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

*/

#include <internetradio.rsg>

#include <stringloader.h>

#include <aknwaitdialog.h> 

#include "irnowplayingwrapper.h"

#include "irmainview.h"

#include "irdebug.h"

#include "irstreamsource.h"

#include "irmediaclient.h"

#include "irctrlcmdobserver.h"

#include "irsessionlogger.h"

#include "irsettings.h"

#include "irisdswrapper.h"

#include "irmetadata.h"

#include "irisdspreset.h"

#include "irautomatedbitrateselection.h" // KHighQuality defined

#include "irdialoglauncher.h"

#include "ircommon.h"

#include "irui.h"

#include "irpubsub.h"

#include "irstreamsourceerrors.h"//KIRStreamSourceTimeOut defined

#include "irnowplayingview.h"

#include "ir.hrh"

#include "irnetworkcontroller.h"

#include "irhistory.h"

#include "irplsview.h"

#include "irnetworkcontrollerobserver.h"

#include "irasfplayer.h"                // CIRAsfPlayer				

#include <mmfcontrollerpluginresolver.h> //to get the supported MIME types

#include "irmainview.h"

#include "irmaincontainer.h"

#include "iractivenetworkobserver.h"

#include "irreportsettings.h"

const TInt KTemporaryUrlMaxLength = 256;

const TInt KUrlbufMaxLength = 256;

//No of volume level is 10 + 1 level 1 level is mute

const TInt KNOVOLUMELEVELS =10;

_LIT(KConst," ");

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

// CIRNowPlayingWrapper* CIRNowPlayingWrapper::NewL()

// function to return an instance of CIRNowPlayingWrapper 

// Two phase constructor

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

//

CIRNowPlayingWrapper* CIRNowPlayingWrapper::NewL(CIRUi& aAppUi,CIRSettings& aIRSettings,

					CIRIsdsWrapper& aIsdsWrapper)

	{

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

	CIRNowPlayingWrapper* self = CIRNowPlayingWrapper::NewLC(aAppUi,aIRSettings,aIsdsWrapper);

	CleanupStack::Pop(self);

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

	return self;

	}

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

// CIRNowPlayingWrapper* CIRNowPlayingWrapper::NewLC()

// Two-phased constructor.

// Create a CIRNowPlayingWrapper object, which will draw itself

// to aRect.

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

//

CIRNowPlayingWrapper* CIRNowPlayingWrapper::NewLC(CIRUi& aAppUi,CIRSettings& aIRSettings,

			CIRIsdsWrapper& aIsdsWrapper)

	{

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

	CIRNowPlayingWrapper* self = new (ELeave) CIRNowPlayingWrapper(aAppUi,aIRSettings,aIsdsWrapper);

	CleanupStack::PushL(self);

	self->ConstructL();

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

	return self;

	}

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

// CIRNowPlayingWrapper::~CIRNowPlayingWrapper()

// Destructor.

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

//

CIRNowPlayingWrapper:: ~CIRNowPlayingWrapper()

	{

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

	if(iNetwork)

		{

		delete iNetwork;

		iNetwork = NULL;	

		}

	iAppUi.GetNowPlayingViewInstance()->DeleteSteroEffect(EFalse);

	if(iPlayer)

		{

		delete iPlayer;

		iPlayer = NULL;

		}

	if(iChannel)

		{

		delete iChannel;

		iChannel = NULL;	

		}

	if( iReportGenerator )

		{

	    iReportGenerator->Close();

		}

	if(iMetaData)

		{

		delete iMetaData;

		iMetaData = NULL;	

		}

	if(iNowPlayingPreset)

		{

		delete iNowPlayingPreset;

		iNowPlayingPreset = NULL;	

		}

	if(iEditStationPreset)

		{

		delete iEditStationPreset;

		iEditStationPreset = NULL;	

		}

	if(iWaitDialog)

		{

		delete iWaitDialog;

		iWaitDialog = NULL;	

		}

	if(iURLArray)

		{

		delete iURLArray;

		iURLArray = NULL;

		}

    iAppUi.iNetworkController->DeleteActiveNetworkObserver(*this);

	if( iAsfPlayer )

		{

		delete iAsfPlayer;

		iAsfPlayer = NULL;

		iAsfStreaming = EFalse;

		}

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

	}

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

// void CIRNowPlayingWrapper::ConstructL()

// Constructs the 

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

//

void CIRNowPlayingWrapper::ConstructL()

	{

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

	//Instantiate StreamSource

	iNetwork = CIRStreamSource::NewL(*this);

	//command channel object creation it is through this component

	//media engine interacts with UI

	iChannel = CIRCtrlCmdObserver::NewL(this,iNetwork);

	//media cient object creation

	iPlayer = CIRMediaClient::NewL(iChannel);

	//Session Log

	iReportGenerator = CIRReportGenerator::OpenL();

    iMetaData = CIRMetaData::NewL();

	//Instantiate ISDS Preset

	iNowPlayingPreset=CIRIsdsPreset::NewL();

	iEditStationPreset = CIRIsdsPreset::NewL();

	//currently not playing

	iPlaying = EFalse;

	//session log should not be terminated on loading cancel

	iTerminatedLogOnCancel = EFalse;

	// when skipping channels used for audio fadein fade out

	iAudioFadein = EFalse;

	// currently set to false since no session created

	iSessionShouldNotEnd = EFalse;

    // set when connect to channel server

	iConnectToServer = EFalse;

	// TO DO: need to remove this variable

	// set when stop is done from nowplayimng view

	iPlayandStop = EFalse;

	// Checks whether network connection has done

	iIsConnected = EFalse;

	// Waitdialog required for for showing buffering

	iWaitDialog = NULL;

	// The multiple url's of a channel are stored

	iURLArray = NULL;

	//Used For Now Playing View

	iDisplayMetaData=EFalse;

	iMarquee = EFalse;

	// The variable is set when player is not supported

    iPlayBack=ETrue;

    // The variable is set when called for cancel network request

    iCancelNetworkRequest=EFalse;

    // The variable is set when buffering waitdialog is deleted

    iDialogCanceled=EFalse;

    // Registering for network controller to get the notification

    // when network is lost or network connection is made

    iAppUi.iNetworkController->RegisterActiveNetworkObserverL(*this);

    // Required when Switching to network

    iNotify=EFalse;

    // Asf streaming

    iAsfPlayer = CIRAsfPlayer::NewL( *this, *this );

    // Valuse set when a session is stared

    iSessionStartedFlag = EFalse;

    // This variable is set when listen from Isds is done

    iListenFromIsds=EFalse;

    // The variable checks whether the nowplaying view is active

    iLaunchNowplaying=EFalse;

    // The variable is required when user does buffering watdialog

    iBufferingRequestCancelled=EFalse;

    iPlaying=EFalse;

    iQualityRequired=-1;

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

	}

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

// void CIRNowPlayingWrapper::CIRNowPlayingWrapper()

// Default Constructor

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

//

CIRNowPlayingWrapper::CIRNowPlayingWrapper(CIRUi& aAppUi,CIRSettings& aIRSettings,

			CIRIsdsWrapper& aIsdsWrapper):iIRSettings(aIRSettings),

              iIsdsWrapper(aIsdsWrapper),iAppUi(aAppUi),

              iAsfPlayer(NULL), iAsfStreaming(EFalse)

	{

	IRLOG_DEBUG( "CIRNowPlayingWrapper::CIRNowPlayingWrapper - Entering" );

	 iSessionStart=EFalse;

	 iChannelConnect=EFalse;

	 IRLOG_DEBUG( "CIRNowPlayingWrapper::NewLC - Exiting" );

	}

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

// MIRStreamSourceObserver::OpenComplete()

// Called when connected to the channel server To implement the fill of buffer

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

//

void CIRNowPlayingWrapper::OpenComplete()

	{

	//once a buffer is completed this api is called as

	//callback

	IRLOG_DEBUG("CIRNowPlayingWrapper::OpenComplete - Entering" );

	/**** ASF streaming changes : begin ****/

	if(!iAsfStreaming)

		{

		iPlayer->BufferFilled();

		}

	/**** ASF streaming changes : begin ****/

    IRLOG_DEBUG("CIRNowPlayingWrapper::OpenComplete - Exiting." );

	}

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

// MIRStreamSourceObserver::ErrorConnecting()

// Called when there is an error when connecting to the channel server  @Param aErrorCode Indicates the type of error as described in irstreamsourceerrors.h---------------------------------------------------------------------------

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

//

void CIRNowPlayingWrapper::ErrorConnecting(TInt aErrorCode)

	{

	IRLOG_DEBUG2( "CIRNowPlayingWrapper::ErrorConnecting(aErrorCode=%d)", aErrorCode );

	iChannelConnect = EFalse;

	// this method fails only if display of info note fails which can be

	// ignored so we use TRAP_IGNORE

	TRAP_IGNORE(DoErrorConnectingL(aErrorCode))

	IRLOG_DEBUG( "CIRNowPlayingWrapper::ErrorConnecting - Exiting." );

	}

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

// MIRStreamSourceObserver::PlayNow()

// Called to indicate to the player to start playing

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

//

void CIRNowPlayingWrapper::PlayNow()

	{

	IRLOG_INFO( "CIRNowPlayingWrapper::PlayNow - Entering" );

	DoPlayingStateChanged( ETrue );

	//sets the configuration data

	TConfig config;

	//by default takes the volume from data base

	//that is when the player is not currently playing

	config.iVolume = iIRSettings.GetVolumeSetting();

	//if current playing we have to do audio fade in.

	//So we set the volume as zero

	if(iAudioFadein)

		{

		config.iVolume = 0;

		}

	TRAPD(err,iPlayer->StartNewPlayerL(config,iNetwork->ContentTypeL()))

	if( err )

		{

		IRLOG_ERROR2( "CIRNowPlayingWrapper::PlayNow - Starting new player failed (err=%d)", err );

		//if error occurs in occurs, displaying

		TRAP_IGNORE(

			DisplayErrorNoteL(R_IRAPP_IRGENERAL_ERROR);

			)

		}

	IRLOG_DEBUG( "CIRNowPlayingWrapper::PlayNow - Exiting." );

	}

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

// MIRStreamSourceObserver::Play()

// Triggers the play after reconnecting to the channel

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

//

void CIRNowPlayingWrapper::Play()

	{

	IRLOG_INFO( "CIRNowPlayingWrapper::Play - Entering" );

	//play is called

	iUrl.Copy(iLastPlayedUrl);

	TInt err = iPlayer->Play();

	if( err )

		{

		IRLOG_ERROR2( "CIRNowPlayingWrapper::Play - Play failed (err=%d), starting new player.", err );

		TConfig config;

		config.iVolume = iIRSettings.GetVolumeSetting();

		TRAPD(err2,iPlayer->StartNewPlayerL(config,iNetwork->ContentTypeL()))

		if( err2 )

			{

			IRLOG_ERROR2( "CIRNowPlayingWrapper::Play - Starting new player failed (err=%d)", err2 );

			//if error occurs in occurs, displaying

			TRAP_IGNORE(

				DisplayErrorNoteL(R_IRAPP_IRGENERAL_ERROR);

				)

			}

		}

	IRLOG_DEBUG("CIRNowPlayingWrapper::Play - Exiting." );

	}

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

// MIRStreamSourceObserver::StopBuffering()

// Called to indicate to the player to stop buffering

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

//

void CIRNowPlayingWrapper::StopBuffering()

	{

	IRLOG_INFO( "CIRNowPlayingWrapper::StopBuffering - Entering" );

	/**** ASF streaming changes : begin ****/

	if(!iAsfStreaming)

		iPlayer->StopMediaBuffering();

	/**** ASF streaming changes : end ****/

	IRLOG_INFO( "CIRNowPlayingWrapper::StopBuffering - Exiting. " );

	}

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

// MIRStreamSourceObserver::ConnectionEstablished(TInt aFeedValue)

// Called to indicate that the connection to channel server is sucessful

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

//

void CIRNowPlayingWrapper::ConnectionEstablished()

	{

	IRLOG_INFO( "CIRNowPlayingWrapper::ConnectionEstablished - Entering." );

	// Reset channel connection request

	TInt bitRate;

	//To Do:Commented code for accp channel

    /*if( iReConnecting )

		{

		 iProgress=EFalse;

		}

	// The control only for the first initial buffering

	// not while reconnecting to same channel i.e, while play & stop.

		// TO Do: here check is dine only for aacp player

		// All content types should be checked

		_LIT(KAudiContent,"aacp");//aacp

		RBuf content;

		TRAP_IGNORE(content.Create(iNetwork->ContentTypeL().Length());)

		TRAP_IGNORE(content.Copy(iNetwork->ContentTypeL());)

		TInt MimeType1= content.Find(KAudiContent);

		if(MimeType1!=KErrNotFound)

			{

			TInt returnValue=0;

			TRAP_IGNORE(returnValue=GetSupportedMimeTypeL());

			if(returnValue==KErrNotFound)

				{

				iCancelNetworkRequest = ETrue;

				iURLCount++;

				if(iURLCount>=iURLArray->MdcaCount())	

					{

					MCtrlCommand(EError,KErrNotSupported);

					content.Close();

					return;

					}

				iNetwork->CancelRequest();

				iDialogCanceled=EFalse;

				DoPlayingStateChanged( EFalse );

				if(iURLArray->MdcaCount())

					{

					//TRAP_IGNORE(CreateWaitDialogL())

					TBuf8<KUrlbufMaxLength> urlbuf;

					urlbuf.Copy(iURLArray->MdcaPoint(iURLCount));

					//connecting to a new channel so multiple URL selection enabled

					//that if current URL doesn't connect we will try to connect to

					//next URL in iURLArray

					iMultipleURLSelect = ETrue;

					iUnconnectedUrl.Copy(urlbuf);

					TRAPD(error,DoConnectToServerL(urlbuf));

					if( error )

						{

						IRLOG_ERROR2( "CIRNowPlayingWrapper::ConnectToChannel - DoConnectToServer failed (error=%d)", error );

						TRAP_IGNORE( DisplayErrorNoteL(R_IRAPP_ERROR_CONNECTION) )

						}

					content.Close();

					return;

					}

				}

			}

		content.Close();*/

	 // here since the connection got established the value set to True

	iChannelConnected=ETrue;

	iLastConnectedPresetId = iNowPlayingPreset->GetId();

	iLastConnectedPresetUniqId = iNowPlayingPreset->UniqId();

	iChannelConnect = EFalse;

	//connecting to a new channel so multiple URL selection disabled

	//if we are able to connect to a particular URL we have to

	//disable trying to connect to next URLs since error conditions after this

	//are to handled differently

	iMultipleURLSelect = EFalse;

	if ( iLastConnectedUrl != iUrl )

		{

		IRLOG_INFO( "CIRNowPlayingWrapper::ConnectionEstablished - Station URL changed, clearing history list and current meta data information" );

		TRAP_IGNORE( ClearMetaDataL() )

		}

	iLastConnectedUrl.Copy(iUrl);

    iReportGenerator->MarkSessionStart();

    if( iSessionStart )

        {

        // Next url to it is connected is logged.

        iReportGenerator->LogServerResult( iUrl, EIRConnected );

        }

	//set the sync state as EPsConnectionSuccessful on a successful connection

	if( !iReConnecting )

		{

		iProgress = ETrue;

		//session end is marked

		//iReportGenerator->MarkSessionStart()

		TRAP_IGNORE(

		TFileName pathtopost=iAppUi.GetPrivatePath();

		pathtopost.Append(KGZipLogFileName);

		//if this api leaves it is ignored

		//we need not do any action if post fails

		//the application should be left unaffected

		if(!iNotify)

		iIsdsWrapper.GetISDSInstance()->IRISDSPostL(pathtopost);

		)

		//starts audio fade out for the previous channel

		/**** ASF streaming changes : begin ****/

		if(!iAsfStreaming)

		iChannel->DoAudioFadeOut();

		/**** ASF streaming changes : end ****/

		/*if(iSessionStart)

			{

			//next url to it is connected is logged

			iReportGenerator->LogServerResult(iUrl,EIRConnected);

			}*/

		}

	else

		{

		// Value set to false becoz the the user is trying 

		 // to connect to same channel so need to update progress

		iProgress = EFalse;

		}

	// This part of code is needed In some cases 

	// When channel is playing and In intial buffer content the bitrate value is Zero

	// So the bitate vaule is taken from the Preset Information and Subscibing 

	iPlayBack=ETrue;

	RProperty::Get ( KUidActiveInternetRadioApp, KIRPSBitrate, bitRate );

	if(bitRate==0)

		{

		TRAP_IGNORE(bitRate= iNowPlayingPreset->GetChannelBitrateL(iURLCount);)