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