/*

* Copyright (c) 2007,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:  Implementation of generic upnp volume state machine

*

*/

// INCLUDES

// avcontroller api

#include <upnpavrenderingsession.h>

#include <upnpavdevice.h> // for device.VolumeCapability()

// volume state machine

#include "upnprenderingstatemachineconstants.h" // option flags

#include "upnpvolumestatemachineobserver.h"

#include "upnpvolumestatemachine.h"

_LIT( KComponentLogfile, "upnprenderingengine.txt");

#include "upnplog.h"

// CONSTANTS

const TInt KCancelTimeMaximum = 3000000;

const TInt KCancelTimeResolution = 500000;

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

TUpnpVSMQueueItem::TUpnpVSMQueueItem( 

    const TUpnpVSMQueueItem::TPropertyType aProperty, const TInt aValue )

    : iProperty( aProperty )

    , iValue( aValue )

    {    

    }

TUpnpVSMQueueItem::TPropertyType TUpnpVSMQueueItem::Property() const

    {

    return iProperty;

    }

TInt TUpnpVSMQueueItem::Value() const

    {

    return iValue;

    }

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

// CUpnpVolumeStateMachine::NewL

// Static constructor.

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

// 

EXPORT_C CUpnpVolumeStateMachine* CUpnpVolumeStateMachine::NewL( 

    MUPnPAVRenderingSession& aSession )

    {

    CUpnpVolumeStateMachine* self =

        new (ELeave) CUpnpVolumeStateMachine( aSession );

    // no 2nd phase construction needed

    return self;

    }

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

// CUpnpVolumeStateMachine::CUpnpVolumeStateMachine

// Default constructor.

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

// 

CUpnpVolumeStateMachine::CUpnpVolumeStateMachine( 

    MUPnPAVRenderingSession& aSession )

    : iSession( aSession )

    {

    __LOG( "VolumeStateMachine: constructor" );

    iVolumeCapability = iSession.Device().VolumeCapability();

    iMuteCapability = iSession.Device().MuteCapability();

    iState = EOffSync;

    iCurrentVolume = KErrNotFound;

    iVolumeToSetAfterMute = KErrNotFound;

    iCurrentMute = KErrNotFound;

    iMuteRequestedByClient = EFalse;

    iCachedVolume = KErrNotFound;

    iCachedMute = KErrNotFound;

    }

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

// CUpnpVolumeStateMachine::~CUpnpVolumeStateMachine

// Destructor.

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

//

EXPORT_C CUpnpVolumeStateMachine::~CUpnpVolumeStateMachine()

    {

    __LOG( "VolumeStateMachine: destructor" );

    }

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

// CUpnpVolumeStateMachine::SetOptions

// sets the option flags for this state machine

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

//

EXPORT_C void CUpnpVolumeStateMachine::SetOptions( TInt aOptions )

    {

    iOptions = aOptions;

    }

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

// CUpnpVolumeStateMachine::Options

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

//

EXPORT_C TInt CUpnpVolumeStateMachine::Options() const

    {

    return iOptions;

    }

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

// CUpnpVolumeStateMachine::SetObserver

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

//

EXPORT_C void CUpnpVolumeStateMachine::SetObserver(

    MUpnpVolumeStateMachineObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// CUpnpVolumeStateMachine::RemoveObserver

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

//

EXPORT_C void CUpnpVolumeStateMachine::RemoveObserver()

    {

    iObserver = NULL;

    }

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

// CUpnpVolumeStateMachine::SyncL

// Synchronises this state machine with the renderer

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

//

EXPORT_C void CUpnpVolumeStateMachine::SyncL()

    {

    __LOG( "VolumeStateMachine: SyncL" );

    if ( iState != EOffSync && iState != EIdle )

        {

        __LOG( "VolumeStateMachine: not synchronizing" );

        return;

        }

    if ( !iVolumeCapability )

        {

        User::Leave( KErrNotSupported );

        }

    iSession.GetVolumeL();

    iState = ESyncing;

    }

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

// CUpnpVolumeStateMachine::SetOffSync

// Forces the state machine off sync

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

//

EXPORT_C void CUpnpVolumeStateMachine::SetOffSync()

    {

    __ASSERTD( !IsBusy(), __FILE__, __LINE__ );

    iState = EOffSync;

    iCurrentVolume = KErrNotFound;

    iVolumeToSetAfterMute = KErrNotFound;

    iCurrentMute = KErrNotFound;

    iMuteRequestedByClient = EFalse;

    }

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

// CUpnpVolumeStateMachine::IsInSync

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

//

EXPORT_C TBool CUpnpVolumeStateMachine::IsInSync() const

    {

    return iState != EOffSync;

    }

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

// CUpnpVolumeStateMachine::SetVolumeL

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

//

EXPORT_C void CUpnpVolumeStateMachine::SetVolumeL( TInt aVolume )

    {

    __LOG1( "VolumeStateMachine: SetVolumeL %d", aVolume );

    __ASSERTD( IsInSync(), __FILE__, __LINE__ );

    if ( !iVolumeCapability )

        {

        User::Leave( KErrNotSupported );

        }

    if ( IsBusy() )

        {

        PushIntoQueueL( TUpnpVSMQueueItem::EVolume, aVolume );

        return;

        }

    // check volume is between given limits

    aVolume = Max( aVolume, KVolumeMin );

    aVolume = Min( aVolume, KVolumeMax );

    if ( aVolume == KVolumeMin && iCurrentVolume > 0 &&

        iMuteCapability && iCurrentMute == KMuteOff &&

        iOptions & Upnp::EConvertVolumeZeroToMute )

        {

        // adjust volume to zero (using mute)

        iSession.SetMuteL( ETrue );

        iState = EAdjustingVolumeToZero;

        }

    else if ( aVolume == KVolumeMin && iCurrentMute == KMuteOn )

        {

        // no need to change volume. Call back directly.

        if ( iObserver )

            {

            iObserver->VolumeChanged(

                KErrNone, iCurrentVolume, ETrue );

            }

        }

    else if ( aVolume > KVolumeMin && iCurrentMute == KMuteOn &&

        !iMuteRequestedByClient )

        {

        // volume is at zero, and renderer is muted.

        // unmute and after that change volume if needed

        iVolumeToSetAfterMute = aVolume;

        iSession.SetMuteL( EFalse );

        iState = EAdjustingVolumeFromZero;

        }

    else if ( aVolume != iCurrentVolume )

        {

        // adjust volume normally

        iSession.SetVolumeL( aVolume );

        iState = EAdjustingVolume;

        }

    else

        {

        // no need to change volume. Call back directly.

        if ( iObserver )

            {

            iObserver->VolumeChanged(

                KErrNone, iCurrentVolume, ETrue );

            }

        }

    }

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

// CUpnpVolumeStateMachine::Volume

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

//

EXPORT_C TInt CUpnpVolumeStateMachine::Volume() const

    {

    __ASSERTD( IsInSync(), __FILE__, __LINE__ );

    TInt vol = iCurrentVolume;

    if ( iCurrentMute && (iOptions & Upnp::EConvertVolumeZeroToMute) )

        {

        vol = KVolumeMin;

        }

    return vol;

    }

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

// CUpnpVolumeStateMachine::SetMuteL

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

//

EXPORT_C void CUpnpVolumeStateMachine::SetMuteL( TBool aMuteState )

    {

    __LOG1( "VolumeStateMachine: SetMuteL", aMuteState );

    __ASSERTD( IsInSync(), __FILE__, __LINE__ );

    if ( !iMuteCapability )

        {

        // Could implement here FAKE MUTE SUPPORT by converting mute

        // to Volume(0). However there is no need to that since no clients

        // use the mute feature.

        User::Leave( KErrNotSupported );

        }

    if ( IsBusy() )

        {

        PushIntoQueueL( TUpnpVSMQueueItem::EMute, aMuteState );

        return;

        }

    // check mute state is between given limits

    aMuteState = Max( aMuteState, KMuteOff );

    aMuteState = Min( aMuteState, KMuteOn );

    if ( aMuteState && !iCurrentMute )

        {

        // mute

        iSession.SetMuteL( ETrue );

        iState = EAdjustingMute;

        }

    else if ( !aMuteState && iCurrentMute )

        {

        // unmute

        iSession.SetMuteL( EFalse );

        iState = EAdjustingMute;

        }

    else

        {

        // no change in mute state. Call back directly.

        if ( iObserver )

            {

            iObserver->MuteChanged(

                KErrNone, iCurrentMute, ETrue );

            }

        }

    }

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

// CUpnpVolumeStateMachine::Mute

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

//

EXPORT_C TBool CUpnpVolumeStateMachine::Mute() const

    {

    __ASSERTD( IsInSync(), __FILE__, __LINE__ );

    return ( (iCurrentMute == KMuteOn) ? KMuteOn : KMuteOff );

    }

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

// CUpnpVolumeStateMachine::IsBusy

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

//

EXPORT_C TBool CUpnpVolumeStateMachine::IsBusy() const

    {

    return iState != EIdle;

    }

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

// CUpnpVolumeStateMachine::HasVolumeCapability

// tests if renderer has volume capability

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

//

EXPORT_C TBool CUpnpVolumeStateMachine::HasVolumeCapability() const

    {

    return iVolumeCapability;

    }

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

// CUpnpVolumeStateMachine::Cancel

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

//

EXPORT_C void CUpnpVolumeStateMachine::Cancel()

    {

    // actually we can not cancel anything, but providing the interface for

    // future purposes

    if ( iState != EIdle )

        {

        __LOG1( "VolumeStateMachine: Canceling in state %d", iState );

        iState = ECancelled;

        for ( TInt t = KCancelTimeMaximum;

            t > 0 && iState != EIdle;

            t -= KCancelTimeResolution )

            {

            User::After( TTimeIntervalMicroSeconds32(

                KCancelTimeResolution ) );

            }

        __LOG1( "VolumeStateMachine: state after cancel: %d", iState );

        }

    }

void CUpnpVolumeStateMachine::HandleVolumeResultInSyncState(

    TInt aError, TInt aVolumeLevel, TBool /*aActionResponse*/ )

    {

    if ( aError == KErrNone )

        {

        iCurrentVolume = aVolumeLevel;

        if ( iMuteCapability )

            {

            // continue to sync mute

            TRAPD( muteError, iSession.GetMuteL() );

            if ( muteError != KErrNone )

                {

                // error syncing mute - callback

                iState = EIdle;

                if ( iObserver )

                    {

                    iObserver->VolumeSyncReady( muteError );

                    }

                }

            }

        else

            {

            // mute not needed - callback

            iCurrentMute = KMuteOff; // assume always off

            iState = EIdle;

            // notify sync initially and volume if changed

            if ( iObserver && iCachedVolume == KErrNotFound )

                {

                iObserver->VolumeSyncReady( KErrNone );

                }

            else if ( iObserver && iCachedVolume != iCurrentVolume )

                {

                iObserver->VolumeChanged(

                    aError, iCurrentVolume, EFalse );

                }

            }

        }

    else

        {

        // error callback

        iState = EIdle;

        if ( iObserver )

            {

            iObserver->VolumeSyncReady( aError );

            }

        }

    }

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

// CUpnpVolumeStateMachine::VolumeResult

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

//

EXPORT_C void CUpnpVolumeStateMachine::VolumeResult(

    TInt aError, TInt aVolumeLevel, TBool aActionResponse )

    {

    __LOG3( "VolumeStateMachine: VolumeResult %d, %d state=%d",

        aError, aVolumeLevel, iState );

    //

    // RESPONSE TO A REQUEST

    //

    if ( aActionResponse )

        {

        //

        // SYNC

        //

        if( iState == ESyncing )

            {

            HandleVolumeResultInSyncState(aError, aVolumeLevel, aActionResponse);            

            }

        //

        // VOLUME ADJUST

        //

        else if ( iState == EAdjustingVolume ||

            iState == EAdjustingVolumeFromZero )

            {

            if ( aError == KErrNone )

                {

                iCurrentVolume = aVolumeLevel;

                }

            iState = EIdle;

            // volume adjust done, call back

            if ( iObserver )

                {

                iObserver->VolumeChanged(

                    aError, iCurrentVolume, ETrue );

                }

            }

        //

        // CANCEL

        //

        else if( iState == ECancelled )

            {

            iState = EIdle;

            }

        }

    //

    // UNSOLICTED VOLUME EVENT

    //

    else

        {

        if ( iState == EIdle )

            {

            if ( aVolumeLevel != iCurrentVolume )

                {

                if ( iCurrentMute == KMuteOn )

                    {

                    __LOG("unsolicted volume event during muted");

                    }

                iCurrentVolume = aVolumeLevel;

                if ( iObserver )

                    {

                    iObserver->VolumeChanged(

                        KErrNone, iCurrentVolume, EFalse );

                    }

                }

            }

        else

            {

            __LOG("ignoring unsolicted volume event in this state");

            }

        }

    iCachedVolume = iCurrentVolume;

    ProcessNextQueuedProperty();

    }

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

// CUpnpVolumeStateMachine::MuteResult

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

//

EXPORT_C void CUpnpVolumeStateMachine::MuteResult(

    TInt aError, TBool aMute, TBool aActionResponse )

    {

    __LOG3( "VolumeStateMachine: MuteResult %d, %d, %d",

        aError, aMute, aActionResponse );

    __LOG1( "VolumeStateMachine: MuteResult in state=%d", iState );

    //

    // RESPONSE TO A REQUEST

    //

    if( aActionResponse )

        {

        //

        // SYNC

        //

        if ( iState == ESyncing )

            {

            if ( aError == KErrNone )

                {

                iCurrentMute = aMute;

                iMuteRequestedByClient = EFalse;

                }

            iState = EIdle;

            // notify sync initially and volume and mute if changed

            if ( iObserver && iCachedMute == KErrNotFound )