/*

* Copyright (c) 2006 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:  Starts and stops audio streams.

*

*/

#include "cspaudiostreams.h"

#include "cspmicrophone.h"

#include "cspspeaker.h"

#include "csplogger.h"

#include "mcspaudiostreamobserver.h"

#include "csptimer.h"

#include <TelephonyAudioRouting.h>

/**

* Timeout initial value.

*/

const TInt KTimeoutInitial = 200000; // 0.2s

/**

* Double the timeout for every retry.

*/

const TInt KTimeoutMultiplier = 2;

// ======== MEMBER FUNCTIONS ========

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

// Static constructor

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

//

CSPAudioStreams* CSPAudioStreams::NewL( )

    {

    CSPAudioStreams* self = 

        CSPAudioStreams::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Static constructor

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

//

CSPAudioStreams* CSPAudioStreams::NewLC(  )

    {

    CSPAudioStreams* self = new( ELeave ) CSPAudioStreams( );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// Destructor

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

//

CSPAudioStreams::~CSPAudioStreams()

    {

    if (iTimer)

        {

        iTimer->CancelNotify();    

        delete iTimer;

        }

    delete iSpeaker;

    delete iMic;

    delete iAudioRouting;

    }

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

// Sets observer for audio stream.

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

//

void CSPAudioStreams::SetAudioStreamObserver( 

    MCSPAudioStreamObserver& aObserver )

    {

    iStreamObserver = &aObserver;

    }

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

// Gives access to mic

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

//

CSPMicrophone& CSPAudioStreams::Mic() const

    {

    return *iMic;

    }

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

// Gives access to speaker

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

//

CSPSpeaker& CSPAudioStreams::Speaker() const

    {

    return *iSpeaker;

    }

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

// From class MCSPAudioStream

// Activates mic and speaker.

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

//

void CSPAudioStreams::StartStreams() 

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::StartStreams");

    if( !IsMicAndSpeakerStarted() )    

        {

        StartMicAndSpeaker(); 

        if( iStreamObserver )

            {

            iStreamObserver->AudioStreamsStarted();

            }

        }

    }

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

// From class MCSPAudioStream

// Deactivates mic and speaker if the streams are active or they are 

// activating. 

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

//

void CSPAudioStreams::StopStreams() 

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::StopStreams");

    if( IsMicAndSpeakerStarted() )

        {

            CSPLOGSTRING(CSPINT, "CSPAudioStreams::StopStreams Stopping");

        iTimer->CancelNotify(); 

        iTimeout = KTimeoutInitial;

        if( iStreamObserver ) 

            {

            iStreamObserver->AudioStreamsGoingToStop();

            }

        iMic->Deactivate();

        iSpeaker->Deactivate();

        }

    }

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

// CSPAudioStreams::VolumeChangedEar

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

//

void CSPAudioStreams::VolumeChangedEar(TInt aVolume)

    {

    CSPLOGSTRING2(CSPINT, "CSPAudioStreams::SetVolume %d", aVolume);

    iVolumeEar = aVolume;

    iSpeaker->SetVolume( aVolume );

    }

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

// CSPAudioStreams::VolumeChangedLoudspeaker

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

//

void CSPAudioStreams::VolumeChangedLoudspeaker(TInt aVolume)

    {

    CSPLOGSTRING2(CSPINT, "CSPAudioStreams::SetVolume %d", aVolume);

    iVolumeLoudspeaker = aVolume;

    iSpeaker->SetVolume( aVolume );

    }

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

// CSPAudioStreams::StoreVolumes

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

//

void CSPAudioStreams::StoreVolumes(TInt aVolumeEar, TInt aVolumeLoudspeaker )

    {

    iVolumeEar = aVolumeEar;

    iVolumeLoudspeaker = aVolumeLoudspeaker;

    }

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

// CSPAudioStreams::ApplyVolume

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

//

void CSPAudioStreams::ApplyVolume(TInt aVolumeEar, TInt aVolumeLoudspeaker )

    {

    CTelephonyAudioRouting::TAudioOutput current = iAudioRouting->Output();

    if ( current == CTelephonyAudioRouting::ELoudspeaker )

        {

        CSPLOGSTRING( CSPINT, "CSPAudioStreams::ApplyVolume Loudspeaker Active: SetVolume" );

        iSpeaker->SetVolume( aVolumeLoudspeaker );

        }

        // else: ear volume should be used

     else if ( current == CTelephonyAudioRouting::EHandset )

        {

        CSPLOGSTRING( CSPINT, "CSPAudioStreams::ApplyVolume Ear Active: SetVolume" );

        iSpeaker->SetVolume( aVolumeEar );

        }

    else

        {

        CSPLOGSTRING2( CSPINT, "CSPAudioStreams::ApplyVolume UNKNOWN AUDIO OUTPUT MODE %d", current );

        // No volume setting

        iSpeaker->SetVolume( aVolumeEar );

        }

    }

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

// CSPAudioStreams::SetMuted

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

//  

void CSPAudioStreams::SetMuted() 

    {

    iMic->SetMuted();

    }

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

// CSPAudioStreams::SetUnmuted

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

//  

void CSPAudioStreams::SetUnmuted() 

    {

    iMic->SetUnmuted();

    }

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

// From class MCSPAudioStreamObserver

// If speaker is already active then the streams are active.

// If speker is not active and it is not activating then speaker then

// activation has failed and start retry timer.

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

//   

void CSPAudioStreams::MicActivatedSuccessfully()

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::MicActivatedSuccessfully" );

    if( iSpeaker->IsActive() )

        {

        // Mic and speaker are active.

        AudioStreamsStarted();

        }

    else if( !iSpeaker->IsActivationOngoing() ) 

        {

        // Start retry timer for activating speaker again

        StartTimer();

        }

    }

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

// From class MCSPAudioStreamObserver

// If mic is already active then streams are active.

// If mic is not active and it is not activating then mic activation has

// failed and start retry timer.

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

//   

void CSPAudioStreams::SpeakerActivatedSuccessfully()

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::SpeakerActivatedSuccessfully" );

    if( iMic->IsActive() ) 

        {

        // Mic and speaker are active.

        AudioStreamsStarted();

        }

    else if( !iMic->IsActivationOngoing() ) 

        {

        // Start retry timer for activating mic again.

        StartTimer();

        }

    }

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

// From class MCSPAudioStreamObserver

// Starts timer for trying activation again.

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

//    

void CSPAudioStreams::MicActivationFailed()

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::MicActivationFailed" );

    // Dont start timer until speaker has stopped activation.

    if( !iSpeaker->IsActivationOngoing() ) 

        {

        StartTimer();

        }

    }

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

// From class MCSPAudioStreamObserver

// Starts timer for trying activation again.

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

// 

void CSPAudioStreams::SpeakerActivationFailed()

    {

    CSPLOGSTRING(CSPINT, "PE.AudioStreams::SpeakerActivationFailed" );

    // Dont start timer until mic has stopped activation.

    if( !iMic->IsActivationOngoing() )

        {

        StartTimer();

        }

    }

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

// From class MCSPTimerObserver

// Notify from CSPTimer that timeout passed. Try to start mic and

// speaker again.

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

// 

void CSPAudioStreams::TimerEvent()

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams.TimerEvent" );

    iTimeout *= KTimeoutMultiplier;

    StartMicAndSpeaker();

    }

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

// CTSEAudioRouteObserver::AvailableOutputsChanged

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

//

void CSPAudioStreams::AvailableOutputsChanged( 

        CTelephonyAudioRouting& /*aTelephonyAudioRouting*/ )

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::AvailableOutputsChanged" );

    }

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

// CTSEAudioRouteObserver::OutputChanged

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

//

void CSPAudioStreams::OutputChanged( 

        CTelephonyAudioRouting& /*aTelephonyAudioRouting*/ )

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::OutputChanged" );

    ApplyVolume(iVolumeEar, iVolumeLoudspeaker);

    }

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

// CSPAudioStreams::SetOutputComplete

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

//

void CSPAudioStreams::SetOutputComplete( CTelephonyAudioRouting& /*aTelephonyAudioRouting*/,

                                         TInt /*aError*/ )

   {

   }  

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

// Constructor

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

//

CSPAudioStreams::CSPAudioStreams( ): iTimeout(KTimeoutInitial)

    {

    }

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

// Second phase constructor

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

//

void CSPAudioStreams::ConstructL( )

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::ConstructL");

    iTimer = CSPTimer::NewL();

    iMic = CSPMicrophone::NewL( *this );

    iSpeaker = CSPSpeaker::NewL( *this );

    #if !defined(__WINSCW__)

    iAudioRouting = CTelephonyAudioRouting::NewL( *this );

    #endif //__WINSCW__        

    }

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

// Resets timer

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

//

void CSPAudioStreams::AudioStreamsStarted()

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::AudioStreamsStarted" );

    iTimeout = KTimeoutInitial; 

    iTimer->CancelNotify();

    }

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

// Starts timer

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

//

void CSPAudioStreams::StartTimer() 

    {

    CSPLOGSTRING(CSPINT, "CSPAudioStreams::StartTimer" );

    iTimer->NotifyAfter( iTimeout, *this );

    }

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

// Starts mic and speaker

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

//

void CSPAudioStreams::StartMicAndSpeaker()

    {

    // if speaker and mic is active then activation does not

    // cause any actions.

    iSpeaker->Activate();

    iMic->Activate();   

    }

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

// Indicated if mic and speaker are started or starting up.

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

//    

TBool CSPAudioStreams::IsMicAndSpeakerStarted()

    {

    TBool areStreamsActive( iSpeaker->IsActive() && iMic->IsActive() );

    TBool areStreamsActivating( iMic->IsActivationOngoing() ||  

        iSpeaker->IsActivationOngoing() || iTimer->IsNotifyOngoing() );

    return areStreamsActive || areStreamsActivating;

    }

//  End of File