/*

* Copyright (c) 2006-2008 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:  Pauses and resumes audio stream.

*

*/

#include    <e32cmn.h>

#include    <mcesession.h>

#include    <mcemediastream.h>

#include    <mceaudiostream.h>

#include    <mcemediasource.h>

#include    <mcemicsource.h>

#include    <mcemediasink.h>

#include    <mcespeakersink.h>

#include    <mcertpsource.h>

#include    <mcertpsink.h>

#include    "svpholdcontext.h"

#include    "svpholdmediahandler.h"

#include    "svplogger.h"

#include    "svpaudioutility.h"

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

// CSVPHoldMediaHandler::CSVPHoldMediaHandler

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

//

CSVPHoldMediaHandler::CSVPHoldMediaHandler()

    {

    }

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

// CSVPHoldMediaHandler::NewL

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

//

CSVPHoldMediaHandler* CSVPHoldMediaHandler::NewL()

    {

    CSVPHoldMediaHandler* self = new ( ELeave ) CSVPHoldMediaHandler;

    return self;

    }

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

// CSVPHoldMediaHandler::~CSVPHoldMediaHandler

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

//

CSVPHoldMediaHandler::~CSVPHoldMediaHandler()

    {

    }

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

// CSVPHoldMediaHandler::PerformMediaActionL

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

//

void CSVPHoldMediaHandler::PerformMediaActionL( CMceMediaStream& aMediaStream,

                                                TSVPHoldRequestType aRequest )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::PerformMediaActionL - IN" );

    CMceMediaStream& boundStream = aMediaStream.BoundStreamL();

    // Always set the priorites because MCE/MCC must have those correctly

    // all the time. This is due to the fact that we may do session update

    // later and then the priority settings need to be correct.

    SVPAudioUtility::SetAudioStreamPrioritiesL( aMediaStream, boundStream );

    switch ( aRequest )

        {

        case ESVPLocalHold:

        case ESVPLocalDoubleHold:

            {            

            HandleLocalHoldingL( aMediaStream, boundStream );

            break;

            }

        case ESVPLocalResume:

        case ESVPLocalDoubleHoldResume:

            {

            HandleLocalResumingL( aMediaStream, boundStream, aRequest );

            break;

            }

        case ESVPRemoteHold:

        case ESVPRemoteDoubleHold:

            {

            HandleRemoteHoldingL( aMediaStream, boundStream, aRequest );

            break;

            }

        case ESVPRemoteResume:

        case ESVPRemoteDoubleHoldResume:

            {

            HandleRemoteResumingL( aMediaStream, boundStream, aRequest );

            break;

            }

        default:

            {

            SVPDEBUG1( "CSVPHoldMediaHandler::PerformMediaActionL: Leave" );

            User::Leave( KErrNotFound );            

            }

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::PerformMediaActionL - Out" );

    }

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

// CSVPHoldMediaHandler::HandleLocalHoldingL

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

//

void CSVPHoldMediaHandler::

HandleLocalHoldingL( CMceMediaStream& aMediaStream,

                     CMceMediaStream& aBoundStream )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalHoldingL - In" );

    // In case of local hold RTP source must be disabled

    if ( aMediaStream.Source() &&

         KMceRTPSource == aMediaStream.Source()->Type() )

        {

        aMediaStream.DisableL();

        }

    else if ( aBoundStream.Source() &&

              KMceRTPSource == aBoundStream.Source()->Type() )

        {

        aBoundStream.DisableL();

        }

    else

        {

        SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalHoldingL:" );

        SVPDEBUG1( "Local hold: No stream - User::Leave" );

        User::Leave( KErrNotFound );

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalHoldingL - Out" );

    }

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

// CSVPHoldMediaHandler::HandleLocalResumingL

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

//

void CSVPHoldMediaHandler::

HandleLocalResumingL( CMceMediaStream& aMediaStream,

                      CMceMediaStream& aBoundStream,

                      TSVPHoldRequestType aRequest )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalResumingL - In" );

    switch ( aRequest )

        {

        case ESVPLocalResume:

            {

            // In case of local resume disabled stream must be enabled              

            SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalResumingL - LocalResume" );

            if ( !aBoundStream.IsEnabled() )

                {

                aBoundStream.EnableL();

                }

            if ( !aMediaStream.IsEnabled() )

                {

                aMediaStream.EnableL();

                }

            break;

            }

        case ESVPLocalDoubleHoldResume:

            {

            // In case of localDH resume RTP source must be enabled

            if ( KMceRTPSource == aMediaStream.Source()->Type() )

                {

                aMediaStream.EnableL();

                }

            else if ( KMceRTPSource == aBoundStream.Source()->Type() )

                {

                aBoundStream.EnableL();

                }

            else

                {

                SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalResumingL:" );

                SVPDEBUG1( "Local DH resume: No stream - User::Leave" );

                User::Leave( KErrNotFound );

                }            

            break;

            }

        default:

            {

            User::Leave( KErrNotFound );

            }

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleLocalResumingL - Out" );

    }

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

// CSVPHoldMediaHandler::HandleRemoteHoldingL

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

//

void CSVPHoldMediaHandler::

HandleRemoteHoldingL( CMceMediaStream& aMediaStream,

                      CMceMediaStream& aBoundStream,

                      TSVPHoldRequestType aRequest )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteHoldingL - In" );

    // In case of remote hold RTP sink must be disabled    

    if ( KMceRTPSource == aMediaStream.Source()->Type() )

        {

        aBoundStream.DisableL();

        if ( ESVPRemoteDoubleHold == aRequest )

            {

            aMediaStream.DisableL();

            }

        }

    else if ( KMceRTPSource == aBoundStream.Source()->Type() )

        {

        aMediaStream.DisableL();

        if ( ESVPRemoteDoubleHold == aRequest )

            {

            aBoundStream.DisableL();

            }

        }

    else

        {

        SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteHoldingL:" );

        SVPDEBUG1( "Remote hold: No stream - User::Leave" );

        User::Leave( KErrNotFound );

        }    

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteHoldingL - Out" );

    }

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

// CSVPHoldMediaHandler::HandleRemoteResumingL

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

//

void CSVPHoldMediaHandler::

HandleRemoteResumingL( CMceMediaStream& aMediaStream,

                       CMceMediaStream& aBoundStream,

                       TSVPHoldRequestType aRequest )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteResumingL - In" )

    switch ( aRequest )

        {

        case ESVPRemoteResume:

            {

            SVPDEBUG2( "CSVPHoldMediaHandler::HandleRemoteResumingL aBound ena: %d",

                aBoundStream.IsEnabled() )

            SVPDEBUG2( "CSVPHoldMediaHandler::HandleRemoteResumingL aMedia ena: %d",

                aMediaStream.IsEnabled() )

            // In case of remote resume disabled stream(s) must be enabled

            if ( !aBoundStream.IsEnabled() )

                {

                SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteResumingL RR 1st ena/dis" )

                aBoundStream.EnableL();

                aMediaStream.DisableL();

                }

            if ( !aMediaStream.IsEnabled() )

                {

                SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteResumingL RR 2nd ena/dis" )

                aMediaStream.EnableL();

                aBoundStream.DisableL();

                }

            break;

            }

        case ESVPRemoteDoubleHoldResume:

            {

            // In case of remoteDH resume RTP sink must be enabled                    

            if ( KMceRTPSource == aMediaStream.Source()->Type() )

                {

                aBoundStream.EnableL();

                aMediaStream.DisableL();

                }

            else if ( KMceRTPSource == aBoundStream.Source()->Type() )

                {

                aMediaStream.EnableL();

                aBoundStream.DisableL();

                }

            else

                {

                SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteResumingL:" );

                SVPDEBUG1( "Remote DH resume: No stream - User::Leave" );

                User::Leave( KErrNotFound );

                }

            break;

            }

        default:

            {

            User::Leave( KErrNotFound );

            }

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::HandleRemoteResumingL - Out" )

    }

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

// CSVPHoldMediaHandler::DisableAudioL

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

//

void CSVPHoldMediaHandler::DisableAudioL( CSVPHoldContext& aContext,

                                          TBool aLeaveSpeakerEnabled )

    {

    if ( aContext.AudioHandlingAllowed() )

        {

        // Disable speaker & microphone

        SVPDEBUG1( "CSVPHoldMediaHandler::DisableAudioL - Disabling audio..." );

        CMceSession* session = aContext.SessionObject();

        const RPointerArray< CMceMediaStream >& streams = session->Streams();

        TInt streamCount = streams.Count();

        for ( TInt i = 0; i < streamCount; i++ )

            {

            CMceMediaStream* mediaStream = streams[ i ];

            TMceMediaType mediaType = mediaStream->Type();

            if ( KMceAudio == mediaType )

                {

                TSVPHoldRequestType request = aContext.HoldRequest();

                CMceMediaStream& boundStream = mediaStream->BoundStreamL();

                DisableAudioStreamL( boundStream, aLeaveSpeakerEnabled );

                DisableAudioStreamL( *mediaStream, aLeaveSpeakerEnabled );

                SVPDEBUG1( "CSVPHoldMediaHandler::DisableAudioL - Audio disabled" );

                }

            }

        }

    }

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

// CSVPHoldMediaHandler::DisableAudioStreamL

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

//

void CSVPHoldMediaHandler::DisableAudioStreamL( CMceMediaStream& aAudioStream,

                                                TBool aLeaveSpeakerEnabled )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::DisableAudioL - In" );

    SVPAudioUtility::DisableMicSourceL( aAudioStream );

    if ( !aLeaveSpeakerEnabled )

        {

        SVPAudioUtility::DisableSpeakerSinkL( aAudioStream.Sinks() );

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::DisableAudioL - Out" );

    }

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

// CSVPHoldMediaHandler::EnableAudioL

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

//

void CSVPHoldMediaHandler::EnableAudioL( CSVPHoldContext& aContext )

    {

    if ( aContext.AudioHandlingAllowed() )

        {

        // Enable speaker & microphone

        SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - Enabling audio..." );

        const RPointerArray< CMceMediaStream >& streams =

            aContext.SessionObject()->Streams();

        const TInt streamCount = streams.Count();

        for ( TInt i = 0; i < streamCount; i++ )

            {

            CMceMediaStream* mediaStream = streams[ i ];

            if ( KMceAudio == mediaStream->Type() )

                {

                EnableAudioL( *mediaStream, aContext );

                }

            }

        }

    }

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

// CSVPHoldMediaHandler::EnableAudioL (private)

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

//

void CSVPHoldMediaHandler::EnableAudioL( CMceMediaStream& aMediaStream,

                                         CSVPHoldContext& aContext )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - Audio enabled In" );

    TBool muted = aContext.Muted();

    TBool mobileOriginated = aContext.IsMobileOriginated();

    // Now enable the audio streams.

    if ( !muted )

        {

        // Normal case, audio not muted

        SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - no mute" );

        EnableAudioStreamL( aMediaStream.BoundStreamL() );

        EnableAudioStreamL( aMediaStream );

        }

    else

        {

        // Enabling depends on the direction of muted stream

        if ( mobileOriginated || aContext.IsRemoteRequest() )

            {

            SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - Bound" );

            EnableAudioStreamL( aMediaStream.BoundStreamL(), EFalse );

            EnableAudioStreamL( aMediaStream, EFalse );

            // Make sure that mic is disabled

            SVPAudioUtility::DisableMicSourceL( *( aMediaStream.Source() ) );

            SVPAudioUtility::DisableMicSourceL( *( aMediaStream.BoundStreamL().

                                                                  Source() ) );

            }

        else

            {

            SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - Main" );

            EnableAudioStreamL( aMediaStream, EFalse );

            EnableAudioStreamL( aMediaStream.BoundStreamL(), EFalse );

            // Make sure that mic is disabled

            SVPAudioUtility::DisableMicSourceL( aMediaStream );

            SVPAudioUtility::DisableMicSourceL( aMediaStream.BoundStreamL() );

            }

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioL - Audio enabled Out" );    

    }

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

// CSVPHoldMediaHandler::EnableAudioStreamL

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

//

void CSVPHoldMediaHandler::EnableAudioStreamL( CMceMediaStream& aAudioStream,

                                               TBool aAllowMicEnable )

    {

    SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioStreamL - In" );

    const RPointerArray< CMceMediaSink >& sinks = aAudioStream.Sinks();

    TInt snkCount( sinks.Count() );

    // Go throug every sink that is associated to that stream

    for ( TInt i = 0; i < snkCount; i++ )

        {

        SVPDEBUG2( "CSVPHoldMediaHandler::EnableAudioStreamL -  Check sink # %d", i );

        if ( !sinks[ i ]->IsEnabled() )

            {

            SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioStreamL - disabled" )

            sinks[ i ]->EnableL();            

            SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioStreamL - ENABLED" )

            }

        }

    if ( aAudioStream.Source() &&

         ( KMceMicSource == aAudioStream.Source()->Type() ||

           KMceRTPSource == aAudioStream.Source()->Type() ) )

        {

        CMceMediaSource* source = aAudioStream.Source();

        if ( !source->IsEnabled() && aAllowMicEnable )

            {

            // Enable source

            source->EnableL();

            SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioStreamL - Source" );

            }

        }

    SVPDEBUG1( "CSVPHoldMediaHandler::EnableAudioStreamL - Out" );

    }