/*
* Copyright (c) 2009 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:
*
*/
// T_TelephonyAudioRouting.cpp

// INCLUDE FILES

#include "T_TelephonyAudioRouting.h"
#include "talogger.h"
#include "MTelephonyAudioRoutingObserver.h"


// -----------------------------------------------------------------------------
// CTelephonyAudioRouting::CTelephonyAudioRouting
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CStubTelephonyAudioRouting::CStubTelephonyAudioRouting( 
        MTelephonyAudioRoutingObserver& aObserver        
        ) : iObserver( aObserver ), iAvailableOutputsTArr(0, NULL, NULL)
    {    
    iOutput = CTelephonyAudioRouting::ENotActive;
    iPreviousOutput = CTelephonyAudioRouting::ENotActive;
    }


// -----------------------------------------------------------------------------
// CTelephonyAudioRouting::ConstructL
// Symbian OS default constructor may leave.
// -----------------------------------------------------------------------------
//
void CStubTelephonyAudioRouting::ConstructL()
    {    
    TEFLOGSTRING( KTAOBJECT, "T_AudioH CTelephonyAudioRouting::ConstructL()" );    
    
    iAudioRoutingObserverCallBack = CIdle::NewL( CActive::EPriorityHigh );
        
    //iAvailableOutputs = new (ELeave) CArrayFixFlat<CTelephonyAudioRouting::TAudioOutput>(5);   
    }


// -----------------------------------------------------------------------------
// CTelephonyAudioRouting::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CStubTelephonyAudioRouting* CStubTelephonyAudioRouting::NewL(
	MTelephonyAudioRoutingObserver& aObserver)
    {
    
    CStubTelephonyAudioRouting* telephonyAudioRouting;
    
    // Check thread local storage:
	if ( Dll::Tls() == NULL )
		{
		telephonyAudioRouting = new ( ELeave ) CStubTelephonyAudioRouting( aObserver );		
		CleanupStack::PushL( telephonyAudioRouting );
		telephonyAudioRouting->ConstructL();
		CleanupStack::Pop( telephonyAudioRouting );
	
		// Store a pointer to the new instance in thread local storage:
		TInt err = Dll::SetTls( static_cast<TAny*>( telephonyAudioRouting ) );
		if ( err == KErrNone )
			{
			return telephonyAudioRouting;
			}
		else
			{
			delete telephonyAudioRouting;
			User::Leave( err );
			return NULL;
			}
		}
	else // CStubTelephonyAudioRouting has been instantiated once already
		{		
		telephonyAudioRouting = static_cast<CStubTelephonyAudioRouting*>( Dll::Tls() );
		return telephonyAudioRouting;
		}
    }
    

// -----------------------------------------------------------------------------
// CTelephonyAudioRouting::NewL
// Two-phased constructor. Leaves if the class does not exist in TLS because 
// this version does not take observer as parameter.
// -----------------------------------------------------------------------------
//
CStubTelephonyAudioRouting* CStubTelephonyAudioRouting::NewL()
    {
    
    CStubTelephonyAudioRouting* telephonyAudioRouting;
    
    // Check thread local storage:
	if ( Dll::Tls() == NULL )
		{
		User::Leave( KErrNotFound );
		return NULL;		
		}
	else // CStubTelephonyAudioRouting has been instantiated once already
		{		
		telephonyAudioRouting = static_cast<CStubTelephonyAudioRouting*>( Dll::Tls() );
		return telephonyAudioRouting;
		}
    }    
    

CStubTelephonyAudioRouting::~CStubTelephonyAudioRouting()     
{

Dll::SetTls( NULL ) ;
iAvailableOutputs.Close();

delete iAudioRoutingObserverCallBack;      
}  
    
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//    
const TArray<CTelephonyAudioRouting::TAudioOutput>& CStubTelephonyAudioRouting::AvailableOutputs()
	{
	iAvailableOutputsTArr = iAvailableOutputs.Array();
	return iAvailableOutputsTArr;
	}
	
	
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//    
CTelephonyAudioRouting::TAudioOutput CStubTelephonyAudioRouting::Output()
{
	return iOutput;
}
	

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  	
void CStubTelephonyAudioRouting::SetOutputL( CTelephonyAudioRouting::TAudioOutput aOutput)
{
	iPreviousOutput = iOutput;
	iOutput = aOutput;
	
	/* if callback has not been called already */
	iAudioRoutingObserverCallBack->Cancel();
	
	//Todo: call observers SetOutputComplete() 
	iAudioRoutingObserverCallBack->Start( TCallBack( DoSetOutputComplete, this ) );
}


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
TInt CStubTelephonyAudioRouting::DoSetOutputComplete( TAny* aAny )
{
	CStubTelephonyAudioRouting* self = 
        static_cast< CStubTelephonyAudioRouting* >( aAny );
    
   
    self->iObserver.SetOutputComplete( *self, KErrNone);   
    return KErrNone;	
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  	
void CStubTelephonyAudioRouting::CommitAvailableOutputsChanged()	
{
	iObserver.AvailableOutputsChanged( *this );   
	return;
}
	
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  	
CTelephonyAudioRouting::TAudioOutput CStubTelephonyAudioRouting::PreviousOutput()	
{
	return iPreviousOutput;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
TInt CStubTelephonyAudioRouting::SetShowNote( TBool aMode )
{
	iShowNote = aMode;
	return 0;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
TInt CStubTelephonyAudioRouting::GetShowNote( TBool& aMode )
{
	aMode = iShowNote;
	return 0;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
MTelephonyAudioRoutingObserver& CStubTelephonyAudioRouting::AudioRoutingObserver()
{
	return iObserver;
}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
void CStubTelephonyAudioRouting::AddAvailableOutput( TAudioOutput aOutput )
{
	iAvailableOutputs.Append(aOutput);
	return;	
}


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
void CStubTelephonyAudioRouting::ResetAvailableOutputs( )
{
	iAvailableOutputs.Reset();
	iAvailableOutputs.Append(CTelephonyAudioRouting::EHandset);
	iAvailableOutputs.Append(CTelephonyAudioRouting::ELoudspeaker);
	
	return;	
}

CStubAudioFactory* CStubAudioFactory::NewL()
    {
    return new( ELeave )CStubAudioFactory();
    }

CStubAudioFactory::CStubAudioFactory()
    {
    
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//  
CStubAudioToneUtility* CStubAudioToneUtility::NewL()
    {
    return new( ELeave )CStubAudioToneUtility();
    }
    
CStubAudioToneUtility::CStubAudioToneUtility()
    {
       
    }

void CStubAudioToneUtility::Reset()
    {
    iPrepareToPlayDesSequenceCalled = EFalse;
    iCancelPlayCallCount = 0;
    }

TBool CStubAudioToneUtility::IsPrepareToPlayDesSequenceCalled() const
    {
    return iPrepareToPlayDesSequenceCalled;
    }

TBool CStubAudioToneUtility::IsCancelPlayCalled() const
    {
    return iCancelPlayCallCount;
    }

TBool CStubAudioToneUtility::IsCancelPlayCalled( TInt aCallCount ) const
    {
    return aCallCount == iCancelPlayCallCount;
    }

void CStubAudioToneUtility::PrepareToPlayDesSequence(const TDesC8& /*aSequence*/)
    {
    iPrepareToPlayDesSequenceCalled = ETrue;
    }

TMdaAudioToneUtilityState CStubAudioToneUtility::State()
    {
    // T_CallHandling test "Test name: MO call, network changes alerting tone status between connecting and
    // connected state" is counting on that state is in EMdaAudioToneUtilityPlaying during the test.
    // 
    return EMdaAudioToneUtilityPlaying;
    }
void CStubAudioToneUtility::CancelPlay()
    {
    iCancelPlayCallCount++;
    }
TInt CStubAudioToneUtility::MaxVolume()
    {
    return 10;
    }

void CStubAudioToneUtility::SetVolume(
    TInt /*aVolume*/ )
    {
    
    }
void CStubAudioToneUtility::SetRepeats(
    TInt /*aRepeatNumberOfTimes*/, 
    const TTimeIntervalMicroSeconds& /*aTrailingSilence*/)
    {
    
    }

void CStubAudioToneUtility::SetPriority(
    TInt /*aPriority*/,
    TMdaPriorityPreference /*aPref*/)
    {
    
    }

void CStubAudioToneUtility::Play()
    {
    
    }

void CStubAudioToneUtility::SetVolumeRamp( 
    const TTimeIntervalMicroSeconds& /*aRampDuration*/)
    {
    
    }

void CStubAudioToneUtility::CancelPrepare()
    {
    
    }

// -----------------------------------------------------------------------------
// TStubAudioFactory::CreateTelephonyAudioRoutingL
// creates stub CTelephonyAudioRouting instance, defined in T_AudoHandlingMT.dll
// -----------------------------------------------------------------------------
//   
CTelephonyAudioRouting* CStubAudioFactory::CreateTelephonyAudioRoutingL( MTelephonyAudioRoutingObserver& aAudioRoutingObserver )      
    {
	return CStubTelephonyAudioRouting::NewL( aAudioRoutingObserver );
    }

CPEAudioToneUtility* CStubAudioFactory::CreateAudioToneUtilityL(
    MMdaAudioToneObserver& /*aToneObserver*/ )
    {
    iStubUtility = CStubAudioToneUtility::NewL();
    return iStubUtility;
    }

CStubAudioToneUtility* CStubAudioFactory::StubUtility() const
    {
    return iStubUtility;
    }