/*

* 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:    

*

*/

// INCLUDE FILES

#include "mccresourceitem.h"

#include "mccuids.hrh"

#include "mcccontrollerlogs.h"

#include "mccmultiplexer.h"

#include "mccinternaldef.h"

#include "mcccamerahandler.h"

#include <mmf/server/mmfaudioinput.h>

#include <mmf/server/mmfaudiooutput.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KMccOneResourceUser = 1;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccResourceItem::NewLC

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

//

CMccResourceItem* CMccResourceItem::NewLC(

    TUint32 aCurrentUserStreamId,

    MDataSink* aSink, 

    MDataSource* aSource, 

    TUint32 aEndpointId,

    TBool aIsMultiplexer )

    {

    CMccResourceItem* self = 

        new ( ELeave ) CMccResourceItem( aCurrentUserStreamId, 

                                         aEndpointId, 

                                         aIsMultiplexer );

    CleanupStack::PushL( self );

    self->ConstructL( aSink, aSource );

    return self;

    }

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

// CMccResourceItem::NewL

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

//

CMccResourceItem* CMccResourceItem::NewL(

    TUint32 aCurrentUserStreamId,

    MDataSink* aSink, 

    MDataSource* aSource, 

    TUint32 aEndpointId,

    TBool aIsMultiplexer )

    {

    CMccResourceItem* self = 

        CMccResourceItem::NewLC( aCurrentUserStreamId,

                                 aSink, 

                                 aSource, 

                                 aEndpointId, 

                                 aIsMultiplexer );

    CleanupStack::Pop( self );

    return self;

    } 

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

// CMccResourceItem::~CMccResourceItem

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

//       

CMccResourceItem::~CMccResourceItem()

    {

    __CONTROLLER( "CMccResourceItem::~CMccResourceItem" )

    delete iMultiplexerItem;

    delete iMultiplexer;

    iUsers.Reset();

    iUsers.Close();

    iKeyFrameInfo.Close();

    __CONTROLLER( "CMccResourceItem::~CMccResourceItem, exit" )

    }

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

// CMccResourceItem::IncreaseRefCount

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

//

TInt CMccResourceItem::IncreaseRefCount( const TMccResourceParams& aUser )

    {

    __CONTROLLER( "CMccResourceItem::IncreaseRefCount" )

    TInt err = iUsers.Append( aUser );

    if ( !err && iMultiplexerItem )

        {

        __CONTROLLER( "CMccResourceItem::IncreaseRefCount, call multiplexer" )

        // Inform also the multiplexer

        err = iMultiplexerItem->IncreaseRefCount( aUser );

        }

    return err;

    }

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

// CMccResourceItem::DecreaseRefCount

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

//        

TBool CMccResourceItem::DecreaseRefCount( const TMccResourceParams& aUser )

    {

    __CONTROLLER( "CMccResourceItem::DecreaseRefCount" )

    TIdentityRelation<TMccResourceParams> comparison( UserMatch );

    TInt index = iUsers.Find( aUser, comparison );

    if ( index != KErrNotFound )

        {

        iUsers.Remove( index );

        // Inform also the multiplexer

        if ( iMultiplexerItem )

            {

            __CONTROLLER( "CMccResourceItem::DecreaseRefCount, call multiplexer" )

            if ( iMultiplexerItem->DecreaseRefCount( aUser ) )

                {

                __CONTROLLER( "CMccResourceItem::DecreaseRefCount, delete multiplexer" )

                delete iMultiplexerItem;

                iMultiplexerItem = 0;

                }

            }

        }

    // If no more users, resource item can be deleted

    if ( iUsers.Count() == 0 )

        {

        __CONTROLLER( "CMccResourceItem::DecreaseRefCount, can be removed" )

        return ETrue;

        }

    __CONTROLLER( "CMccResourceItem::DecreaseRefCount, cannot be removed" )

    iCurrentUserStreamId = iUsers[ 0 ].iStreamId;

    return EFalse;

    }

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

// CMccResourceItem::RefCount

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

//    

TInt CMccResourceItem::RefCount() const

    {

    return iUsers.Count();

    }

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

// CMccResourceItem::EndpointId

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

//

TUint32 CMccResourceItem::EndpointId() const

    {

    return iEndpointId;

    }

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

// CMccResourceItem::IsNetworkResource

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

//    

TBool CMccResourceItem::IsNetworkResource() const

    {

    TBool isNetworkResource = iSink ? 

        iSink->DataSinkType().iUid == KImplUidRtpDataSink :

        iSource->DataSourceType().iUid == KImplUidRtpDataSource;

    return isNetworkResource;

    }

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

// CMccResourceItem::IsResourceActive

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

// 

TBool CMccResourceItem::IsResourceActive() const

    {

    return ( iState == MMccResources::EPrepared || 

             iState == MMccResources::EStarted );

    }

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

// CMccResourceItem::IsSharedResource

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

//     

TBool CMccResourceItem::IsSharedResource() const

    {

    TBool sharable = iIsMultiplexer || ( RefCount() > KMccOneResourceUser );

    return sharable;

    }

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

// CMccResourceItem::IsStandbyResource

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

//     

TBool CMccResourceItem::IsStandbyResource() const

    {

    TBool standby( EFalse );

    if ( iSink && iSink->DataSinkType() == KUidMmfAudioOutput )

        {

        for ( TInt i = 0; i < iUsers.Count() && !standby; i++ )

            {

            standby = iUsers[ i ].iIsStandby;

            }

        }

    return standby;

    }

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

// CMccResourceItem::NeedsCamera

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

// 

TBool CMccResourceItem::NeedsCamera( CMccCameraHandler& aCameraHandler )

    {

    TBool needsCamera( EFalse );

    if ( iState == MMccResources::EStarted )

        {

        needsCamera = ETrue;

        }

    else if ( iState == MMccResources::EPrepared )

        {

        needsCamera = aCameraHandler.IsViewFinderEnabled();

        }

    else if ( iState == MMccResources::EResourcePaused )

        {

        needsCamera = aCameraHandler.IsViewFinderEnabled();

        }		

    else

        {

        // NOP

        }

    return needsCamera;

    }

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

// CMccResourceItem::SetResourceStateL

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

//    

TBool CMccResourceItem::SetResourceStateL( 

    TUint32 aStreamId, 

    MMccResources::TResourceState aState,

    TBool aStandbyControl,

    TBool aDtmfControl )

    {

    __CONTROLLER_INT1( "CMccResourceItem::SetResourceStateL, old state:", iState )

    __CONTROLLER_INT1( "CMccResourceItem::SetResourceStateL, proposed state:", aState )

    TBool effectiveStateChange = EFalse;

    if ( iMultiplexerItem )

        {

        __CONTROLLER( "CMccResourceItem::SetResourceStateL, multiplexer decision" )

        effectiveStateChange = 

            iMultiplexerItem->SetResourceStateL( 

                aStreamId, aState, aStandbyControl, aDtmfControl );

        // Actual resource follows multiplexer states

        iState = iMultiplexerItem->CurrentState();

        }

    else

        {

        __CONTROLLER( "CMccResourceItem::SetResourceStateL, resource usage allowed" )

        // For shared resources, all resource state change operations should

        // be passed further.

        effectiveStateChange = IsSharedResource();

        TBool isStandbyResource = IsStandbyResource();

        if ( isStandbyResource || aDtmfControl )

            {

            // Special handling for standby resource and dtmf

            SpecialStateChangeL( aStreamId, 

                                 aState, 

                                 aStandbyControl, 

                                 aDtmfControl, 

                                 effectiveStateChange );

            }

        else

            {

            TBool stateOK( EFalse );

            switch ( aState )

                { 

                case MMccResources::EPrepared:

                    {

                    if ( MMccResources::EConstructed == iState )

                        {

                        stateOK = ETrue;

                        }

                    else if ( iState == MMccResources::EStarted ||

                              iState == MMccResources::EResourcePaused )

                        {

                        // Endpoint is already started by other user,

                        // state is not "downgraded"

                        aState = iState;

                        stateOK = ETrue;

                        }

                    else

                        {

                        // NOP

                        }

                    break;

                    }

                case MMccResources::EStarted:

                    {

                    if ( MMccResources::EPrepared == iState || 

                         MMccResources::EResourcePaused == iState )

                        {

                        stateOK = ETrue;

                        }  

                    break;

                    }

                case MMccResources::EResourcePaused:

                    {

                    if ( MMccResources::EStarted == iState )

                        {

                        stateOK = ETrue;

                        }  

                    break;

                    }

                case MMccResources::EResourceStopped:

                    {

                    // Endpoint cannot be stopped until all its users

                    // want to stop it.

                    if ( !UserStopL( aStreamId ) )

                        {

                        aState = iState;

                        effectiveStateChange = EFalse;

                        }

                    stateOK = ETrue; 

                    break;

                    }

                default:

                    {

                    break;

                    }

                }

            if ( aState != iState )

                {

                __ASSERT_ALWAYS( stateOK || effectiveStateChange, 

                                 User::Leave( KErrNotReady ) );

                iState = aState;

                effectiveStateChange = ETrue;

                }

            }

        }

    __CONTROLLER_INT1( "CMccResourceItem::SetResourceStateL, effective change:", 

                       effectiveStateChange )

    __CONTROLLER_INT1( "CMccResourceItem::SetResourceStateL, exit with state:", 

                       iState )

    return effectiveStateChange;

    }

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

// CMccResourceItem::IsSink

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

//

TBool CMccResourceItem::IsSink() const

    {

    return ( iSink != 0 );

    }

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

// CMccResourceItem::IsSource

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

//        

TBool CMccResourceItem::IsSource() const

    {

    return ( iSource != 0 );

    }

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

// CMccResourceItem::IsInternal

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

//        

TBool CMccResourceItem::IsInternal() const

    {

    TBool isInternal = iSink ? IsInternal( iSink->DataSinkType().iUid ) :

                               IsInternal( iSource->DataSourceType().iUid );

    return isInternal;

    }

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

// CMccResourceItem::Source

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

//        

MDataSource* CMccResourceItem::Source()

    {

    return iSource;

    }

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

// CMccResourceItem::Sink

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

//       

MDataSink* CMccResourceItem::Sink()

    {

    return iSink;

    }

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

// CMccResourceItem::MultiplexerL

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

//

CMccMultiplexer* CMccResourceItem::MultiplexerL()

    {

    if ( !iMultiplexerItem )

        {

        iMultiplexerItem = 

            CMccResourceItem::NewL( iCurrentUserStreamId,

                                    iSink, 

                                    iSource, 

                                    iEndpointId, 

                                    ETrue );

        // Update ref count immediately

        for ( TInt i = 0; i < iUsers.Count(); i++ )

            {

            User::LeaveIfError( 

                iMultiplexerItem->IncreaseRefCount( iUsers[ i ] ) );

            }

        }

    return iMultiplexerItem->GetMultiplexerL();

    }

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

// CMccResourceItem::GetMultiplexerL

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

//   

CMccMultiplexer* CMccResourceItem::GetMultiplexerL()

    {

    __ASSERT_ALWAYS( iMultiplexer, User::Leave( KErrNotReady ) );

    return iMultiplexer;

    }

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

// CMccResourceItem::UserSessionMatch

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

//     

TBool CMccResourceItem::UserSessionMatch( 

    const TMccResourceParams& aUser1, 

    const TMccResourceParams& aUser2 )

    {

    return ( aUser1.iSessionId == aUser2.iSessionId );

    }

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

// CMccResourceItem::UserMatch

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

//     

TBool CMccResourceItem::UserMatch( 

    const TMccResourceParams& aUser1, 

    const TMccResourceParams& aUser2 )

    {

    return ( aUser1.iStreamId == aUser2.iStreamId );

    }

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

// CMccResourceItem::UserMatchNotStrict

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

//     

TBool CMccResourceItem::UserMatchNotStrict( 

    const TMccResourceParams& aUser1, 

    const TMccResourceParams& aUser2 )

    {

    if ( aUser1.iLinkId )

        {

        return ( aUser1.iLinkId == aUser2.iLinkId );

        }

    return UserMatch( aUser1, aUser2 );

    }

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

// CMccResourceItem::UserMatchActive

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

//     

TBool CMccResourceItem::UserMatchActive( 

    const TMccResourceParams& /*aUser1*/, 

    const TMccResourceParams& aUser2 )

    {

    // First argument is the search term, in this case it can be ignored

    return ( !aUser2.iIsStopped );

    }

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

// CMccResourceItem::UsersInfoL

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