/*
* 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:  Stream source main class implementation
*
*/


#include <e32property.h>
#include "irpubsubkeys.h"

#include "irdebug.h"
#include "irnetworkcontroller.h"
#include "irstreamsource.h"
#include "irstreamsourceerrors.h"
#include "irstreamsourceobserver.h"
#include "irstationconnection.h"


// Constants
const TInt KIRSCConnectionCleanupDelay = 10000000;
const TInt KHundred = 100;

// ---------------------------------------------------------------------------
//  CIRStreamSource::ConnectToServerL
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRStreamSource::ConnectToServerL( const TDesC& aUrl )
    {
    IRLOG_INFO2( "CIRStreamSource::ConnectToServerL - aUrl=%S", &aUrl );
	#ifndef __WINS__
	 					 	 
    //Connecting for the first time
 /*****************************testing*****************/
    	/*if ( iCurrentConnection )	
	    {
	    iCurrentConnection->Close();
	    }
	AsyncCleanupConnection( iCurrentConnection );
    iCurrentConnection = NULL;*/
/*****************************************************/
   	
   		#endif //__WINS__
    if ( iNetworkControllerHandle->GetNetworkStatus() )
        {
        iReConnecting = EFalse;
        DoConnectL( aUrl );    
        }
    else
	    {
		iStreamSourceObserver.ErrorConnecting( KIRStreamSourceConnectionError );
	    }
    IRLOG_DEBUG( "CIRStreamSource::ConnectToServerL - Exiting." );
	}

// ---------------------------------------------------------------------------
//  CIRStreamSource::ReconnectL
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRStreamSource::ReconnectL( const TDesC& aUrl )
    {
    IRLOG_INFO( "CIRStreamSource::ReconnectL" );
	if ( iNetworkControllerHandle->GetNetworkStatus() )
	    {
        iReConnecting = ETrue;
        DoConnectL( aUrl );
	    }
	else
		{
		iStreamSourceObserver.ErrorConnecting( KIRStreamSourceConnectionError );
		}
    IRLOG_DEBUG( "CIRStreamSource::ReconnectL - Exiting." );
	}
	
// ---------------------------------------------------------------------------
//  CIRStreamSource::DoConnectL
//  Creates the connection object which initiates the connection
//  to the channel server
// ---------------------------------------------------------------------------
//
void CIRStreamSource::DoConnectL( const TDesC& aUrl )
	{
    IRLOG_INFO2( "CIRStreamSource::DoConnectL iCurrentConn=%d", iCurrentConnection );	

    AsyncCleanupConnection( iNewConnection );
    iNewConnection = NULL;        
    StaticConnectionCleanupCallback( this ); // delete it (and them) now

    CIRStationConnection* connection = CIRStationConnection::NewL( *this, *this );
    CleanupStack::PushL( connection );
    iConnections.AppendL( connection );
    CleanupStack::Pop( connection );
    iNewConnection = connection;
    
    iNewConnection->ConnectL( aUrl );
    
	IRLOG_INFO2( "CIRStreamSource::DoConnectL - Exiting, iNewConnection=%d.", iNewConnection );
	}

// ---------------------------------------------------------------------------
//  CIRStreamSource::CIRStreamSource
//  Default Constructor
// ---------------------------------------------------------------------------
//
CIRStreamSource::CIRStreamSource( MIRStreamSourceObserver &aObserver ):
	iStreamSourceObserver( aObserver )
    {
	// no implementation
    }

// ---------------------------------------------------------------------------
// CIRStreamSource::~CIRStreamSource
// Default Destructor
// ---------------------------------------------------------------------------
//
CIRStreamSource::~CIRStreamSource()
    {    
    IRLOG_DEBUG( "CIRStreamSource::~CIRStreamSource" );
	
    // close the network controller handle	
	if( iNetworkControllerHandle )
		{
		iNetworkControllerHandle->Close();	
        }
	delete iSocketTimer;
    
    delete iConnectionCleanupTimer;
    
    iConnections.ResetAndDestroy();
    iConnections.Close();
    }

// --------------------------------------------------------------------------- 
//  CIRStreamSource::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CIRStreamSource *CIRStreamSource::NewL( MIRStreamSourceObserver   &aObserver )
    {
    CIRStreamSource *self = new( ELeave ) CIRStreamSource( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CIRStreamSource::ConstructL
// ---------------------------------------------------------------------------
//
void CIRStreamSource::ConstructL()
    {
    // Open handle to network controller
    iNetworkControllerHandle = CIRNetworkController::OpenL();
    // create a timer for timeouts
    iSocketTimer = CIRSocketTimeOutTimer::NewL( CActive::EPriorityHigh,	*this ); 
    }

// --------------------------------------------------------------------------- 
//  CIRStreamSource::FilltheBuffer
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRStreamSource::FilltheBuffer( TDes8& aInputBuffer )
    {
    IRLOG_DEBUG( "CIRStreamSource::FilltheBuffer" );

    if( iCurrentConnection )
    	{
   	 	iCurrentConnection->FillBuffer( aInputBuffer );
    	}
    else
    	{
    	iReConnecting = ETrue;
    	iStreamSourceObserver.ErrorConnecting( KIRStreamSourceNoResponse );
    	}
    IRLOG_DEBUG( "CIRStreamSource::FilltheBuffer - Exiting." );
    }

// ---------------------------------------------------------------------------
// CIRStreamSource::TimerExpired
// ---------------------------------------------------------------------------
//
void CIRStreamSource::TimerExpired()
	{
	// CancelRequest gets called by UI.We could of course call it here, but you never
	// know what it would cause in UI without thorough testing.
	iStreamSourceObserver.ErrorConnecting( KIRStreamSourceTimeOut );
	}

// ---------------------------------------------------------------------------
// CIRStreamSource::TimerExpired
// ---------------------------------------------------------------------------
//
void CIRStreamSource::MetadataReceived( const CIRMetaData& aMetaData )
    {
    TRAP_IGNORE( iStreamSourceObserver.HandleMetaDataReceivedL( aMetaData ) )
    }

// ---------------------------------------------------------------------------
// CIRStreamSource::AudioDataEvent
// ---------------------------------------------------------------------------
//
void CIRStreamSource::AudioDataEvent( const TInt aResponseCode,	TInt aValue )
	{
	IRLOG_DEBUG3( "CIRStreamSource::AudioDataEvent - aResponseCode=%d, aFeedValue=%d", aResponseCode, aValue );
	switch( aResponseCode )
		{
		case EBufferFilled:
			{
			IRLOG_DEBUG( "CIRStreamSource::AudioDataEvent - EBufferFilled" );
			// Indicate the observer
			if( !iReConnecting )
				{
				iStreamSourceObserver.PlayNow();
				}
			else
				{
				iStreamSourceObserver.Play();	
				}
			}
			break;
		case EOpenComplete:
			{
			IRLOG_DEBUG( "CIRStreamSource::AudioDataEvent - EOpenComplete" );
			// Indicate the observer that streamsource buffering complete	
			iStreamSourceObserver.OpenComplete();
			}
			break;
		case EBufferPercentage:
			{
			// Indicate buffering progress to observer
			iStreamSourceObserver.UpdateProgress( aValue );
			if ( aValue == KHundred )
				{
			    IRLOG_INFO( "CIRStreamSource::AudioDataEvent - 100 percent EBufferPercentage" );				
				iSocketTimer->Cancel();
				} 
			}
			break;
		default:
			{
			__ASSERT_DEBUG( EFalse, User::Invariant() );
			}
			break;	
		}
	IRLOG_DEBUG( "CIRStreamSource::AudioDataEvent - Exiting." );	
	}
	
// ---------------------------------------------------------------------------
//  CIRStreamSource::ContentTypeL
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CIRStreamSource::ContentTypeL()
	{
    __ASSERT_ALWAYS( iCurrentConnection, User::Leave( KErrNotReady ) );

    return iCurrentConnection->ContentType();
	}

// ---------------------------------------------------------------------------
// CIRStreamSource::CancelRequest
// ---------------------------------------------------------------------------
//
EXPORT_C void CIRStreamSource::CancelRequest()
	{
	IRLOG_INFO3( "CIRStreamSource::CancelRequest - iNewConnection=%d, iCurrentConnection=%d", iNewConnection, iCurrentConnection );	
	iSocketTimer->Cancel();
		
    if ( iNewConnection )		
        {
        iNewConnection->Close();
        AsyncCleanupConnection( iNewConnection );
        iNewConnection = NULL;
        }
    else
        {
		if ( iCurrentConnection )
		    {
		    iCurrentConnection->Close();		    
		    }
		AsyncCleanupConnection( iCurrentConnection );
		iCurrentConnection = NULL;
        }        
	IRLOG_DEBUG( "CIRStreamSource::CancelRequest - Exiting." );	
	}

// ---------------------------------------------------------------------------
// CIRStreamSource::ConnectionSuccessfulL
// ---------------------------------------------------------------------------
//
void CIRStreamSource::ConnectionSuccessful( CIRStationConnection* aConnection )
	{
	IRLOG_INFO3( "CIRStreamSource::ConnectionSuccessful aConnection=%d, iCurrentConn=%d", 
	             aConnection, iCurrentConnection );	
	__ASSERT_DEBUG( aConnection->ConnectionType() == CIRStationConnection::EIRCandidate,
	                User::Invariant() );
	                
    // publish the url
    RProperty::Set( KUidActiveInternetRadioApp, KIRPSChannelUrl, aConnection->Uri() );	

	if( !iReConnecting )
		{
		iStreamSourceObserver.StopBuffering();
	    }	
	    
	if ( iCurrentConnection )	
	    {
	    iCurrentConnection->Close();
	    }
	AsyncCleanupConnection( iCurrentConnection );
    iCurrentConnection = NULL;

    aConnection->SetConnectionType( CIRStationConnection::EIRPermanent );
    iCurrentConnection = aConnection;
    iNewConnection = NULL;

    iStreamSourceObserver.ConnectionEstablished();
    // Buffering starts now, so let's set the timer.
	TTimeIntervalMicroSeconds32 timeOut( KBufferingTimeOut );
	iSocketTimer->Cancel();
	iSocketTimer->After( timeOut );

	IRLOG_DEBUG( "CIRStreamSource::ConnectionSuccessful - Exiting." );	
	}

// ---------------------------------------------------------------------------
// CIRStreamSource::ConnectionError
// ---------------------------------------------------------------------------
//
void CIRStreamSource::ConnectionError( CIRStationConnection* aConnection, TInt aErrorCode )
	{
	IRLOG_ERROR3( "CIRStreamSource::ConnectionError - aConnection=%d, aErrorCode=%d", aConnection, aErrorCode );
    
	if ( aConnection->ConnectionType() == CIRStationConnection::EIRCandidate )
	    {
        AsyncCleanupConnection( aConnection );
        iNewConnection = NULL; // To Do: implement more sophisticated pending connection handling.	    
		iReConnecting = ETrue;        
	    }
    else
        {
        if ( aErrorCode == KIRStreamSourceDisconnected )
            {
			CancelRequest();            
            }
        }	    
	iStreamSourceObserver.ErrorConnecting( aErrorCode );
	IRLOG_DEBUG( "CIRStreamSource::ConnectionError - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRStreamSource::AsyncCleanupConnection
// ---------------------------------------------------------------------------
//
void CIRStreamSource::AsyncCleanupConnection( CIRStationConnection* aConnection )
    {
    IRLOG_DEBUG2( "CIRStreamSource::AsyncCleanupConnection - aConnection=%d.", aConnection );    
    // let's not double-add any connections.
    if ( aConnection )
        {
        IRLOG_INFO2( "CIRStreamSource::AsyncCleanupConnection - Scheduled deletion of connection %d.", aConnection );            
        delete iConnectionCleanupTimer;
        iConnectionCleanupTimer = NULL;
        TRAPD( err, iConnectionCleanupTimer = CPeriodic::NewL( CActive::EPriorityStandard ) )
        if ( err == KErrNone )
            {
            iConnectionCleanupTimer->Start( KIRSCConnectionCleanupDelay, 0,
            			 TCallBack( StaticConnectionCleanupCallback, this ) );
            }
        else
            {
            IRLOG_ERROR2( "CIRStreamSource::AsyncCleanupConnection - CPeriodic creation left with %d.", err );
            // delete the existing dying connections.
            StaticConnectionCleanupCallback( this );    
            }
        aConnection->SetConnectionType( CIRStationConnection::EIRDying );                    
        }
    IRLOG_DEBUG( "CIRStreamSource::AsyncCleanupConnection - Exiting." );                    
    }

// ---------------------------------------------------------------------------
// CIRStreamSource::StaticConnectionCleanupCallback
// ---------------------------------------------------------------------------
//
TInt CIRStreamSource::StaticConnectionCleanupCallback( TAny* aSelfPtr )
	{
	CIRStreamSource* self = reinterpret_cast<CIRStreamSource*>( aSelfPtr );
	if ( self )
		{
	IRRDEBUG2("CIRStreamSource::StaticConnectionCleanupCallback - Entering", KNullDesC );

        IRLOG_DEBUG( "CIRStreamSource::StaticConnectionCleanupCallback." );
		delete self->iConnectionCleanupTimer;
		self->iConnectionCleanupTimer = NULL;
		TInt it = self->iConnections.Count() - 1;
		while ( it >= 0 )
		    {
		    if ( self->iConnections[it]->ConnectionType() == CIRStationConnection::EIRDying )
		        {
		 IRRDEBUG2("CIRStreamSource::StaticConnectionCleanupCallback - Entering1", KNullDesC );
        IRLOG_INFO2( "CIRStreamSource::StaticConnectionCleanupCallback - Deleting connection %d.", 
                self->iConnections[it] );		    		        
        delete self->iConnections[it];
        self->iConnections.Remove( it );
		 IRRDEBUG2("CIRStreamSource::StaticConnectionCleanupCallback - Exiting1", KNullDesC );

		        }
		    it--;
		    }
	IRRDEBUG2("CIRStreamSource::StaticConnectionCleanupCallback - Exiting", KNullDesC );

        IRLOG_DEBUG( "CIRStreamSource::StaticConnectionCleanupCallback - Exiting." );		    
		}
	return KErrNone;
	}