/*

* Copyright (c) 2007 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 for audio feature unit object.

*

*/

#include <accpolaudiounitbase.h>

#include <accpolaudiotopologyobjectcon.h>

#include <accpolvolumecontrol.h>

#include <accpolmutecontrol.h>

#include <accpolinputcontrol.h>

#include "acc_debug.h"

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

// CAccPolAudioUnitBase::CAccPolAudioUnitBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAccPolAudioUnitBase::CAccPolAudioUnitBase(

    const TTopologyConObjectType aObjecType,

    CAccPolObjectCon* aObject ) :

    CAccPolObjectBase( aObjecType, aObject )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() -Enter" );

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() - Return" );

    }

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

// CAccPolAudioUnitBase::CAccPolAudioUnitBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAccPolAudioUnitBase::CAccPolAudioUnitBase( const TUint8 aUnitId,

    const TTopologyConObjectType aObjecType ) :

    CAccPolObjectBase( aObjecType )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() - Enter" );

    iUnitId = aUnitId;

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() - Return" );

    }

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

// CAccPolAudioUnitBase::CAccPolAudioUnitBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAccPolAudioUnitBase::CAccPolAudioUnitBase( const TUint8 aUnitId,

    const TUint8 aSourceId,

    const TTopologyConObjectType aObjecType ) :

    CAccPolObjectBase( aObjecType )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() -Enter" );

    iUnitId = aUnitId;

    iSourceId.Append( aSourceId );

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::CAccPolAudioUnitBase() - Return" );

    }

// Destructor

EXPORT_C CAccPolAudioUnitBase::~CAccPolAudioUnitBase()

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::~CAccPolAudioUnitBase() - Enter" );

    iSourceId.Close();

    TInt count = iAudioControls.Count();

    if( count > 0 )

        {

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

            {

            delete iAudioControls.operator[]( i );

            }

        }

    iAudioControls.Close();

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::~CAccPolAudioUnitBase() - Return" );

    }

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

// CAccPolAudioUnitBase::operator()

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

//

EXPORT_C CAccPolAudioUnitBase& CAccPolAudioUnitBase::operator=(

    const CAccPolAudioUnitBase& aAudioUnitBaseObject )

    {

    TRAP_IGNORE ( CopyL ( aAudioUnitBaseObject ) );

    return ( *this );

    }

void CAccPolAudioUnitBase::CopyL ( const CAccPolAudioUnitBase& aAudioUnitBaseObject )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::operator() - Enter" );

    // Copy base	

    CAccPolObjectBase::operator=( ( CAccPolObjectBase& )aAudioUnitBaseObject );

    //Copy Unit id

    iUnitId = aAudioUnitBaseObject.UnitId();

    RArray<TInt> sourceIds;

    CleanupClosePushL( sourceIds );

    //Copy source Ids

    aAudioUnitBaseObject.GetSourceIds( sourceIds );

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

        {

        iSourceId.AppendL( sourceIds.operator[]( i ) );

        }

    //Copy previous unit id

    iPreUnitId = aAudioUnitBaseObject.PreviousUnitId();

    //Copy audio controls.

    RPointerArray<CAccPolAudioControlBase> audioControls;

    CleanupClosePushL( audioControls );

    aAudioUnitBaseObject.GetAudioControlsL( audioControls );

    for( TInt j = 0; j < audioControls.Count(); j++ )

        {

        TUint8 objectType;

        objectType = audioControls.operator[]( j )->ObjectType();

        switch( objectType )

            {

            case EAccPolAudioVolumeControlObject:

                {

                CAccPolVolumeControl *volumeControl =

                    CAccPolVolumeControl::NewL();

                CleanupStack::PushL( volumeControl );

                *volumeControl

                    = *( CAccPolVolumeControl* )audioControls.operator[]( j );

                iAudioControls.AppendL( volumeControl );

                CleanupStack::Pop();

                }

                break;

            case EAccPolAudioMuteControlObject:

                {

                CAccPolMuteControl *muteControl = CAccPolMuteControl::NewL();

                CleanupStack::PushL( muteControl );

                *muteControl

                    = *( CAccPolMuteControl* )audioControls.operator[]( j );

                iAudioControls.AppendL( muteControl );

                CleanupStack::Pop();

                }

                break;

            case EAccPolAudioInputControlObject:

                {

                CAccPolInputControl *inputControl = CAccPolInputControl::NewL();

                CleanupStack::PushL( inputControl );

                *inputControl

                    = *( CAccPolInputControl* )audioControls.operator[]( j );

                iAudioControls.AppendL( inputControl );

                CleanupStack::Pop();

                }

                break;

            default:

                {

                User::Leave( KErrNotSupported );

                }

                break;

            }

        }

    CleanupStack::PopAndDestroy (); //audioControls...dont use ResetAndDestroy on this!

    CleanupStack::PopAndDestroy (); //sourceIds

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::operator() - Return" );

    }

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

// CAccPolAudioUnitBase::PreviousUnitId

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

//

TUint8 CAccPolAudioUnitBase::PreviousUnitId() const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::PreviousUnitId() - Enter" );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::PreviousUnitId() - Return %d", iPreUnitId );

    return iPreUnitId;

    }

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

// CAccPolAudioUnitBase::SetPreviousUnitId

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

//

void CAccPolAudioUnitBase::SetPreviousUnitId( TUint8 aPreUnitId )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SetPreviousUnitId() - Enter" );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SetPreviousUnitId() - PreUnit Id %d", aPreUnitId );

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SetPreviousUnitId() - Return" );

    iPreUnitId = aPreUnitId;

    }

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

// CAccPolAudioUnitBase::UnitId

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

//

EXPORT_C TUint8 CAccPolAudioUnitBase::UnitId() const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::UnitId() - Enter" );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::UnitId() - Return %d", iUnitId );

    return iUnitId;

    }

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

// CAccPolAudioUnitBase::SourceId

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

//

EXPORT_C TUint8 CAccPolAudioUnitBase::SourceId() const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceId() - Enter" );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceId() - Return %d", iSourceId.operator[]( 0 ) );

    return ( TUint8 )iSourceId.operator[]( 0 );

    }

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

// CAccPolAudioUnitBase::GetSourceIds

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

//

EXPORT_C void CAccPolAudioUnitBase::GetSourceIds( RArray<TInt>& aSourceIds ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceIds() - Enter" );

    TInt count = iSourceId.Count();

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

        {

        API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceIds() Return SourceId=%d", iSourceId.operator[]( i ) );

        aSourceIds.Append( ( TInt )iSourceId.operator[]( i ) );

        }

    }

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

// CAccPolAudioUnitBase::SourceIdCount

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

//

EXPORT_C TInt CAccPolAudioUnitBase::SourceIdCount() const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceIdCount() -Enter" );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::SourceIdCount() return count=%d", iSourceId.Count() );

    return iSourceId.Count();

    }

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

// CAccPolAudioUnitBase::AddSourceIdL

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

//

EXPORT_C void CAccPolAudioUnitBase::AddSourceIdL( TUint8 aSourceId )

    {

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::AddSourceIdL() Enter - Source Id=%d", aSourceId );

    iSourceId.AppendL( aSourceId );

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::AddSourceIdL() - Return" );

    }

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

// CAccPolAudioUnitBase::GetAudioControlL

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

//

EXPORT_C TBool CAccPolAudioUnitBase::GetAudioControlL(

    TTopologyConObjectType aObjectType,

    TUint32 aChannel,

    CAccPolAudioControlBase*& aAudioControl ) const

    {

    API_TRACE_2( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlL() - Object type=%d, Channel number=%d", aObjectType, aChannel );

    TBool bFound( EFalse );

    aAudioControl = NULL;

    if( aObjectType == EAccPolAudioVolumeControlObject || aObjectType

        == EAccPolAudioMuteControlObject )

        {

        TInt count = iAudioControls.Count();

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

            {

            if( iAudioControls.operator[]( i )->ObjectType() == aObjectType

                && iAudioControls.operator[]( i )->Channel() == aChannel )

                {

                aAudioControl = iAudioControls.operator[]( i );

                bFound = ETrue;

                break;

                }

            }

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlL() - Return=%d", bFound );

    return bFound;

    }

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

// CAccPolAudioUnitBase::GetAudioControlsL

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

//

EXPORT_C void CAccPolAudioUnitBase::GetAudioControlsL( TUint32 aChannel,

    RPointerArray<CAccPolAudioControlBase>& aAudioControls ) const

    {

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlsL() - Channel number=%d", aChannel );

    TInt count = iAudioControls.Count();

    API_TRACE_1( "[AccFW: ACCPOLICY] CAccPolAudioUnitBase::GetAudioControlsL() - count=%d", count );

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

        {

        if( iAudioControls.operator[]( i )->Channel() == aChannel )

            {

            aAudioControls.AppendL( iAudioControls.operator[]( i ) );

            }

        }

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlL() Return" );

    }

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

// CAccPolAudioUnitBase::GetAudioControlsL

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

//

EXPORT_C void CAccPolAudioUnitBase::GetAudioControlsL(

    RPointerArray<CAccPolAudioControlBase>& aAudioControls ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlsL() -Enter" );

    TInt count = iAudioControls.Count();

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlsL() - count=%d", count );

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

        {

        aAudioControls.AppendL( iAudioControls.operator[]( i ) );

        }

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioControlsL() - Return" );

    }

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

// CAccPolAudioUnitBase::GetAudioControlsL

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

//

EXPORT_C TBool CAccPolAudioUnitBase::GetNextAudioUnitL(

    CAccPolAudioUnitBase*& aAudioUnit ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetNextAudioUnitL() - Enter" );

    RPointerArray<CAccPolAudioUnitBase> audioUnits;

    TBool bFound = EFalse;

    reinterpret_cast<CAccPolAudioTopologyObjectCon*> ( iObjectContainer )->GetAudioUnitsL(

        audioUnits );

    TInt count = audioUnits.Count();

    aAudioUnit = NULL;

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

        {

        if( iSourceId.Count() != 0 ) //JNI

            {

            API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] SourceId - count=%d", iSourceId.Count() );

            TInt sourceid = iSourceId.operator[]( 0 );

            if( iSourceId.operator[]( 0 )

                == audioUnits.operator[]( i )->UnitId() )

                {

                aAudioUnit = audioUnits.operator[]( i );

                aAudioUnit->SetPreviousUnitId( UnitId() );

                bFound = ETrue;

                break;

                }

            }

        }

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetNextAudioUnitL() - Return=%d", bFound );

    return bFound;

    }

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

// CAccPolAudioUnitBase::GetAudioControlsL

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

//

EXPORT_C TBool CAccPolAudioUnitBase::GetPreviousAudioUnitL(

    CAccPolAudioUnitBase*& aAudioUnit ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetPreviousAudioUnitL() - Enter" );

    TBool bFound = EFalse;

    RPointerArray<CAccPolAudioUnitBase> audioUnits;

    reinterpret_cast<CAccPolAudioTopologyObjectCon*> ( iObjectContainer )->GetAudioUnitsL(

        audioUnits );

    TInt count = audioUnits.Count();

    aAudioUnit = NULL;

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

        {

        if( PreviousUnitId() == audioUnits.operator[]( i )->UnitId() )

            {

            aAudioUnit = audioUnits.operator[]( i );

            bFound = ETrue;

            break;

            }

        }

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetPreviousAudioUnitL() - Return=%d", bFound );

    return bFound;

    }

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

// CAccPolAudioUnitBase::GetAudioControlsL

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

//

EXPORT_C void CAccPolAudioUnitBase::GetAudioUnitListL(

    RPointerArray<CAccPolAudioUnitBase>& aAudioUnits ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioUnitListL() - Enter" );

    RPointerArray<CAccPolAudioUnitBase> audioUnits;

    reinterpret_cast<CAccPolAudioTopologyObjectCon*> ( iObjectContainer )->GetAudioUnitsL(

        audioUnits );

    TInt audioUnitCount = audioUnits.Count();

    TInt sourceIdCount = iSourceId.Count();

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioUnitListL() - Source id count=%d", sourceIdCount );

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

        {

        for( TInt j = 0; j < audioUnitCount; j++ )

            {

            if( iSourceId.operator[]( i )

                == audioUnits.operator[]( j )->UnitId() )

                {

                aAudioUnits.AppendL( audioUnits.operator[]( j ) );

                audioUnits.operator[]( j )->SetPreviousUnitId( UnitId() ); //JNI               

                }

            }

        }

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::GetAudioUnitListL() - Return" );

    }

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

// CAccPolAudioUnitBase::AddControlL

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

//

EXPORT_C void CAccPolAudioUnitBase::AddControlL(

    CAccPolAudioControlBase& aAudioControl )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::AddControlL() - Enter" );

    aAudioControl.SetUnitId( iUnitId );

    TUint8 objectType;

    objectType = aAudioControl.ObjectType();

    switch( objectType )

        {

        case EAccPolAudioVolumeControlObject:

            {

            CAccPolVolumeControl *volumeControl = CAccPolVolumeControl::NewL();

            CleanupStack::PushL( volumeControl );

            *volumeControl = ( CAccPolVolumeControl& )aAudioControl;

            iAudioControls.AppendL( volumeControl );

            CleanupStack::Pop();

            }

            break;

        case EAccPolAudioMuteControlObject:

            {

            CAccPolMuteControl *muteControl = CAccPolMuteControl::NewL();

            CleanupStack::PushL( muteControl );

            *muteControl = ( CAccPolMuteControl& )aAudioControl;

            iAudioControls.AppendL( muteControl );

            CleanupStack::Pop();

            }

            break;

        case EAccPolAudioInputControlObject:

            {

            CAccPolInputControl *inputControl = CAccPolInputControl::NewL();

            CleanupStack::PushL( inputControl );

            *inputControl = ( CAccPolInputControl& )aAudioControl;

            iAudioControls.AppendL( inputControl );

            CleanupStack::Pop();

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::AddControlL() - Return" );

    }

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

// CAccPolObjectBase::ExternalizeBaseLd

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

//

EXPORT_C void CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL(

    RWriteStream& aStream ) const

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL() - Enter" );

    TInt count( KErrNone );

    //Add data

    aStream.WriteUint8L( iUnitId );

    count = iSourceId.Count();

    aStream.WriteInt8L( iSourceId.Count() );

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

        {

        aStream.WriteUint8L( ( TUint8 )iSourceId.operator[]( i ) );

        }

    count = iAudioControls.Count();

    aStream.WriteInt8L( count );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Unit id         = %d", iUnitId );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Source id count = %d", iSourceId.Count() );

    API_TRACE_1( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeAudioUnitBaseL - Audio controls count = %d", iAudioControls.Count() );

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

        {

        iAudioControls[i]->ExternalizeL( aStream );

        }

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::ExternalizeBaseL - Return" );

    }

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

// CAccPolObjectBase::InternalizeBaseL

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

//

EXPORT_C void CAccPolAudioUnitBase::InternalizeAudioUnitBaseL(

    RReadStream& aStream )

    {

    API_TRACE_( "[AccFW: ACCPOLAUDIODEVICETOPOLOGY] CAccPolAudioUnitBase::InternalizeAudioUnitBaseL() - Enter" );

    TInt count( KErrNone );