/*

* Copyright (c) 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:  Implementation of the VtUiUtility class.

*

*/

// INCLUDE FILES

#include    "lcvtutility.h"

#include    <featmgr.h>

#include    <mvtengmedia.h>

#include    <cvtlogger.h>

// Characters to open number entry.

//_LIT( KVtUiDTMFCharacters, "0123456789*#" );

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

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

// LcVtUtility::GetAudioRoutingAvailability

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

//

void LcVtUtility::GetAudioRoutingAvailability(

        MVtEngAudio& aAudio,

        TInt& aAvailable )

    {

    aAvailable = 0;    

    //const TBool bluetoothAudioSupported = ETrue;        

    MVtEngAudio::TAudioRoutingState routingState;

    if ( aAudio.GetRoutingState( routingState ) == KErrNone )

        {

        // Deactivate BT handsfree.

        if ( /*bluetoothAudioSupported &&*/

             IsAudioRoutingAvailable(

                aAudio,

                routingState,

                MVtEngAudio::EAudioBT,

                MVtEngAudio::EAudioHandset ) )

            {

            aAvailable |= EDeactivateBtHandsfree;

            }

        // Activate BT handsfree.

        if ( /*bluetoothAudioSupported &&*/

             ( IsAudioRoutingAvailable(

                 aAudio,

                 routingState,

                 MVtEngAudio::EAudioHandset,

                 MVtEngAudio::EAudioBT ) ||

               IsAudioRoutingAvailable(

                aAudio,

                routingState,

                MVtEngAudio::EAudioLoudspeaker,

                MVtEngAudio::EAudioBT ) ) )

            {

            aAvailable |= EActivateBtHandsfree;

            }

        // Deactivate loudspeaker

        if ( IsAudioRoutingAvailable(

                aAudio,

                routingState,

                MVtEngAudio::EAudioLoudspeaker,

                MVtEngAudio::EAudioHandset ) )

            {

            aAvailable |= EDeactivateLoudspeaker;

            }

        // Activate loudspeaker

        if ( IsAudioRoutingAvailable(

                aAudio,

                routingState,

                MVtEngAudio::EAudioHandset,

                MVtEngAudio::EAudioLoudspeaker ) ||

             ( /*bluetoothAudioSupported &&*/ 

               IsAudioRoutingAvailable( 

                   aAudio,

                   routingState, 

                   MVtEngAudio::EAudioBT, 

                   MVtEngAudio::EAudioLoudspeaker ) ) )

            {

            aAvailable |= EActivateLoudspeaker;

            }

        }

    }

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

// LcVtUtility::GetOutgoingMediaState

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

//

void LcVtUtility::GetOutgoingMediaState(

        MVtEngMedia& aMedia,

        TInt& aAvailable )

    {

    TInt outgoingMediaState;

    const TInt err =

        aMedia.GetMediaState(

            MVtEngMedia::EMediaOutgoing,

            outgoingMediaState );

    if ( err == KErrNone )

        {

        // If source is still image, then video sending is off.

        MVtEngMedia::TMediaSource source;

        if ( aMedia.GetSource( source ) == KErrNone )

            {

            if ( source == MVtEngMedia::EMediaStillImage )

                {

                outgoingMediaState &= ~MVtEngMedia::EMediaVideo;

                }

            }

        TBool freezeSupported;

        if( aMedia.GetFreezeSupported( freezeSupported ) == KErrNone )

            {

            TBool isFrozen;

            if( freezeSupported && aMedia.GetFreezeState( isFrozen ) == KErrNone )

                {

                if( isFrozen )

                    {

                    outgoingMediaState &= ~MVtEngMedia::EMediaVideo;

                    }

                }

            }

        }

    else

        {

        outgoingMediaState =

            ( MVtEngMedia::EMediaAudio | MVtEngMedia::EMediaVideo );

        }

    aAvailable = outgoingMediaState;

    }

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

// LcVtUtility::GetIncomingMediaState

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

//

void LcVtUtility::GetIncomingMediaState(

        MVtEngMedia& aMedia,

        TInt& aAvailable )

    {

    TInt mediaState;

    const TInt err =

        aMedia.GetMediaState(

            MVtEngMedia::EMediaIncoming,

            mediaState );

    if ( err != KErrNone )

        {

        mediaState =

            ( MVtEngMedia::EMediaAudio | MVtEngMedia::EMediaVideo );

        }

    aAvailable = mediaState;

    }

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

// LcVtUtility::HasStillImage

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

//

TBool LcVtUtility::HasStillImage(

        MVtEngMedia& aMedia )

    {

    TInt caps;

    const TInt capsErr = aMedia.GetSourcesCaps( caps );

    return ( capsErr == KErrNone ) &&

           ( caps & MVtEngMedia::ESourceCapsStillImage );

    }

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

// LcVtUtility::GetFreezeState

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

//

TBool LcVtUtility::GetFreezeState(

        MVtEngMedia& aMedia )

    {

    TBool isFrozen;

    const TInt err = aMedia.GetFreezeState( isFrozen );

    if ( err == KErrNone )

        {

        return isFrozen;

        }

    else //provider was not ready

        {

        return EFalse;

        }

    }

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

// LcVtUtility::IsFreezeSupported

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

//

TBool LcVtUtility::IsFreezeSupported(

        MVtEngMedia& aMedia )

    {

    TBool isFreezeSupported;

    const TInt err = aMedia.GetFreezeSupported( isFreezeSupported );

    if ( err == KErrNone )

        {

        return isFreezeSupported;

        }

    else //provider was not ready

        {

        return EFalse;

        }

    }

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

// LcVtUtility::GetVideoQuality

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

//

void LcVtUtility::GetVideoQuality(

            MVtEngMedia& aMedia,

            MVtEngMedia::TVideoQuality& aVideoQuality )

    {

    aMedia.GetVideoQuality( aVideoQuality );

    }

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

// LcVtUtility::GetObjectSharingState

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

//

void LcVtUtility::GetObjectSharingState(

    MVtEngMedia& aMedia,

    MVtEngMedia::TShareObjectState& aShareObjectState )

    {

    aMedia.GetObjectSharingState( aShareObjectState );

    }

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

// LcVtUtility::IsZoomAllowed

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

//

TBool LcVtUtility::IsZoomAllowed(

        MVtEngMedia& aMedia )

    {

    TBool result = EFalse;

    TInt currentStep;

    if ( aMedia.GetCurrentZoomStep( currentStep ) == KErrNone )

        {

        TInt max;

        if ( aMedia.GetMaxZoomStep( max ) == KErrNone )

            {

            // Zooming is allowed if maximum zoom step is greater than

            // zero and camera is in use (and not still image / none).

            TInt avail;

            GetOutgoingMediaState( aMedia, avail );

            result = ( max > 0 ) && ( avail & MVtEngMedia::EMediaVideo );

            }

        }

    __VTPRINT2( DEBUG_GEN, "Ui.AllowZoom.%d", result )

    return result;

    }

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

// LcVtUtility::HasCameras

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

//

TBool LcVtUtility::HasCameras( MVtEngMedia& aMedia )

    {

    TInt sourceCaps;

    if ( aMedia.GetSourcesCaps( sourceCaps ) != KErrNone )

        {

        sourceCaps = 0;

        }

    return ( sourceCaps & MVtEngMedia::ESourceCapsPrimaryCamera ) ||

           ( sourceCaps & MVtEngMedia::ESourceCapsSecondaryCamera );

    }

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

// LcVtUtility::IsAudioRoutingAvailable

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

//

TBool LcVtUtility::IsAudioRoutingAvailable(

        MVtEngAudio& aAudio,

        const MVtEngAudio::TAudioRoutingState aCurrent,

        const MVtEngAudio::TAudioRoutingState aSource,

        const MVtEngAudio::TAudioRoutingState aTarget )

    {

    TBool result = EFalse;

    if ( aCurrent == aSource )

        {

        TBool available = EFalse;

        TInt err = aAudio.GetRoutingAvailability( aTarget, available );

        result = ( ( err == KErrNone ) && ( available ) );

        }

    return result;

    }

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

// LcVtUtility::IsDTMFCharacter

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

//

TBool LcVtUtility::IsDTMFCharacter( const TChar aChar )

    {

    return EFalse;

    /*

    return

        ( KVtUiDTMFCharacters().Locate( aChar ) != KErrNotFound );

        */

    }

//  End of File