/*

* Copyright (c) 2004-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:  Video call setting data

*

*/

// INCLUDE FILES

#include    "CVtEngSettings.h"

#include    <cvtlogger.h>

#include    "MVtEngSettingObserver.h"

#include    "VtEngUtils.h"

#include    "VtEngPanic.h"

#include    <telincallvolcntrlcrkeys.h>

#include    <rphcltserver.h>

#include    <cphcltimagehandler.h>

#include    <videotelephonyinternalcrkeys.h>

#include    <LogsDomainCRKeys.h>

#include    <settingsinternalcrkeys.h>

#include    <videotelephonyvariant.hrh>

// CONSTANTS

// Granularity for observer array.

const TInt KVtEngObserverArrayGranularity = 2;

// Volume default level.

const TInt KVtEngVolumeDefaultLevel = 4;

// Video quality frame rate configuration buffer size

const TInt KVtEngVQFRBufferSize = 32;

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

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

// CVtEngSettings::CVtEngSettings

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

// might leave.

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

//

CVtEngSettings::CVtEngSettings() :

    iVariantReadOnlyValues( KErrNotReady )

    {

    iCLI.iValid = EFalse;

    }

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

// CVtEngSettings::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngSettings::ConstructL()

    {

    __VTPRINTENTER( "Settings.ConstructL" )

    iSelectVolumeIdle = CIdle::NewL( CActive::EPriorityHigh );

    iObserverItems = new ( ELeave ) 

        CArrayFixFlat<TObserverItem>( KVtEngObserverArrayGranularity );

    // Ear volume CR listener.

    iCRProxy = &CVtEngUtility::CRProxy();

    CreateDataObserverL( this, KCRUidInCallVolume, KTelIncallEarVolume, 

        CCenRepNotifyHandler::EIntKey );   

    // IHF volume listener.

    CreateDataObserverL( 

        this, KCRUidInCallVolume, KTelIncallLoudspeakerVolume,

        CCenRepNotifyHandler::EIntKey );

    // Call duration listener.

    CreateDataObserverL( this, KCRUidLogs, KLogsShowCallDuration, 

        CCenRepNotifyHandler::EIntKey );

    // Still image listener.

    CreateDataObserverL( this, KCRUidTelephonySettings, KSettingsVTStillImage,

        CCenRepNotifyHandler::EIntKey );

    // Still image path listener.

    CreateDataObserverL( 

        this, KCRUidTelephonySettings, KSettingsVTStillImagePath,

        CCenRepNotifyHandler::EStringKey );

    ReadVariationsL();

    ResetAll();

    TInt validImage( 0 );

    TInt err = iCRProxy->Get( KCRUidTelephonySettings, 

        KSettingsVTStillImage, validImage );

    __VTPRINT3( DEBUG_DETAIL, "Settings.ConL: use image", err, validImage )

    if ( !err && validImage )

        {

        __VTPRINT( DEBUG_DETAIL, "Settings.ConL: VALID" )

        iConfig.iVideo.iImageIsValid = ETrue;

        }

    TInt value( 0 ); // not shown

    err = iCRProxy->Get( KCRUidLogs, KLogsShowCallDuration, value );

    if ( err == KErrNone )

        {

        iConfig.iCallTimerOn = ( value == 1 ) ? ETrue : EFalse;

        }

    // Initialize the volume levels.

    // If value retrieval fails, use defaults.

    if ( iCRProxy->Get( KCRUidInCallVolume, 

        KTelIncallEarVolume, iConfig.iAudio.iVolume.iHandsetVolume ) 

        != KErrNone )

        {

        iConfig.iAudio.iVolume.iHandsetVolume = KVtEngVolumeDefaultLevel;

        }

    if ( iCRProxy->Get( KCRUidInCallVolume, KTelIncallLoudspeakerVolume, 

        iConfig.iAudio.iVolume.iHandsfreeVolume ) != KErrNone )       

        {

        iConfig.iAudio.iVolume.iHandsfreeVolume = KVtEngVolumeDefaultLevel;

        }

    // Open connection to phone server

    RPhCltServer phoneClient;

    User::LeaveIfError( phoneClient.Connect() );

    CleanupClosePushL( phoneClient );

	CPhCltImageHandler* stillH;

	stillH = CPhCltImageHandler::NewL();

    CleanupStack::PushL( stillH );

	// Load images

	RFile file;

	TInt res = stillH->OpenDefaultVtImage( file );

	file.Close();

	iDefaultStillImageDefined = ( res == KErrNone ) ? ETrue : EFalse;

     // Cleanup

	CleanupStack::PopAndDestroy( 2 ); // phoneClient, stillH, imageParams

    __VTPRINTEXIT( "Settings.ConstructL" )

    }

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

// CVtEngSettings::NewL

// Two-phased constructor.

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

//

CVtEngSettings* CVtEngSettings::NewL()

    {

    CVtEngSettings* self = new( ELeave ) CVtEngSettings;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CVtEngSettings::~CVtEngSettings

// Destructor.

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

//

CVtEngSettings::~CVtEngSettings()

    {

    __VTPRINTENTER( "Settings.~" )

    delete iSelectVolumeIdle;

    delete iObserverItems;

    delete iDataportInfo;

    __VTPRINTEXIT( "Settings.~" )

    }

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

// CVtEngSettings::Config

// Returns configuration.

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

//

const CVtEngSettings::TVtEngVideoCallConfig& CVtEngSettings::Config() const

    {

    return iConfig;

    }

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

// CVtEngSettings::SetCurrentVolume

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

//

void CVtEngSettings::SetCurrentVolume( TBool aVolume )

    {

    TBool old = iConfig.iAudio.iCurrentVolume;

    iConfig.iAudio.iCurrentVolume = aVolume;

    if ( iSelectVolumeObserver && ( !old && aVolume ) || ( old && !aVolume ) )

        {

        iSelectVolumeIdle->Cancel();

        iSelectVolumeIdle->Start(

            TCallBack( DoInformSelectVolumeObserver, this ) );

        }

    }

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

// CVtEngSettings::CurrentVolume

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

//

TBool CVtEngSettings::CurrentVolume() const

    {

    return iConfig.iAudio.iCurrentVolume;

    }

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

// CVtEngSettings::SetVolume

// Sets output volue setting.

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

//

TInt CVtEngSettings::SetVolume( 

        const TInt aHandsetVolume, 

        const TInt aHandsfreeVolume,

        const TBool aInternal )

    {

    __VTPRINTENTER( "Settings.SetVolume" )

    __VTPRINT3( DEBUG_DETAIL, "Settings:SetVolume hs=%d, ihf=%d", 

        aHandsetVolume, aHandsfreeVolume  )

    __VTPRINT2( DEBUG_DETAIL, "Settings:Internal=%d", aInternal )

    TInt volume ( 0 );    

    TInt res( KErrNone );

    if ( aInternal )

        {

        if ( iConfig.iAudio.iVolume.iHandsfreeVolume != aHandsfreeVolume )

            {

            iConfig.iAudio.iVolume.iHandsfreeVolume = 

                ValidVolume( aHandsfreeVolume );

            }

        if ( iConfig.iAudio.iVolume.iHandsetVolume != aHandsetVolume )

            {

            iConfig.iAudio.iVolume.iHandsetVolume = 

                ValidVolume( aHandsetVolume );

            }

        }

    else

        {        

	    iCRProxy->Get( KCRUidInCallVolume, 

	        KTelIncallEarVolume, volume );

	    if ( volume != aHandsetVolume ) 

	        {

	        iCRProxy->Set( KCRUidInCallVolume, 

	            KTelIncallEarVolume, aHandsetVolume );

	        }

	    iCRProxy->Get( KCRUidInCallVolume, 

	        KTelIncallLoudspeakerVolume, volume );

	    if ( volume != aHandsfreeVolume )

	        {

	        iCRProxy->Set( KCRUidInCallVolume, 

	            KTelIncallLoudspeakerVolume, aHandsfreeVolume );         

	        }

        }

    __VTPRINTEXITR( "Settings.SetVolume res=%d", res )

    return res;

    }

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

// CVtEngSettings::GetVolume

// Gets audio volume.

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

//

TInt CVtEngSettings::GetVolume(

    TInt& aVolume, 

    const TBool aHandsfree,

    const TBool aInternal ) const

    {

    TInt res( KErrNone );

    if ( aInternal )

        {

        if ( aHandsfree )

            {

            aVolume = iConfig.iAudio.iVolume.iHandsfreeVolume;

            }

        else

            {

            aVolume = iConfig.iAudio.iVolume.iHandsetVolume;

            }

        }

    else

        {

        if ( aHandsfree )

            {          

            res = iCRProxy->Get( KCRUidInCallVolume,

                KTelIncallLoudspeakerVolume, aVolume );

            }

        else

            {

            res = iCRProxy->Get( KCRUidInCallVolume, 

                KTelIncallEarVolume, aVolume );              

            }

        }

    __VTPRINTEXITR( "Settings.GetVolume res=%d", res )

    return res;

    }

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

// CVtEngSettings::SetRouting

// Sets audio routing setting.

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

//

void CVtEngSettings::SetRouting( 

    const MVtEngAudio::TVtEngRoutingSetting& aState )

    {

    iConfig.iAudio.iRouting = aState;

    }

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

// CVtEngSettings::SetVideoEnabled

// Sets video enabled setting.

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

//

void CVtEngSettings::SetVideoEnabled( const TBool aEnabled )

    {

    __VTPRINT2( DEBUG_GEN , "Settings.SVE",aEnabled )

    iConfig.iVideo.iVideoEnabled = aEnabled;

    }

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

// CVtEngSettings::SetConnectReady

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

//

void CVtEngSettings::SetConnectReady()

    {

    iConfig.iReadyForConnect = ETrue;

    }

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

// CVtEngSettings::SetDataportLoaned

// Sets dataport loaning status

// 

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

//

void CVtEngSettings::SetDataportLoaned( TBool aLoaned )

	{

	__VTPRINTENTER( "Settings.SetDataportLoaned" )

	iConfig.iIsDataportLoaned = aLoaned;

	__VTPRINTEXIT( "Settings.SetDataportLoaned" )

	}

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

// CVtEngSettings::ResetAll

// Reset all settings.

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

//

void CVtEngSettings::ResetAll()

    {

    __VTPRINT( DEBUG_GEN , "Settings.RA" )

    iConfig.iAudio.iRouting = KVtEngDefaultAudioRouting;

    iConfig.iVideo.iVideoEnabled = ETrue;

    iConfig.iReadyForConnect = EFalse;

	iConfig.iIsDataportLoaned = EFalse;

    // call duration setting not cleared

    }

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

// CVtEngSettings::NotifyChangeL

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

//

void CVtEngSettings::NotifyChangeL( 

            TSettingId aId,

            MVtEngSettingObserver& aObserver )

    {

    __VTPRINTENTER( "Settings.NotifyChangeL" )

    __VTPRINT2( DEBUG_GEN, "Settings.NC id %d", aId )

    switch ( aId )

        {

        case ESelectVolume:

            iSelectVolumeObserver = &aObserver;

            break;

        case EDataportInfo:

            iDataportObserver = &aObserver;

            break;

        // others are CenRep items

        default:

        {

        const TInt count( iObserverItems->Count() );

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

            {

            TObserverItem& item = iObserverItems->At( index );

            if ( item.iId == aId && item.iObserver == &aObserver )

                {

                __VTPRINT( DEBUG_GEN, "Settings.NC.already" )

                __VTPRINTEXIT( "Settings.NotifyChangeL" )

                return;

                }

            }

        TObserverItem item;

        item.iId = aId;

        switch ( aId )

            {

            case EStillImage:

                item.iIntKey = KSettingsVTStillImage;

                item.iUid = KCRUidTelephonySettings;

                break;

            case EStillImagePath:

                item.iIntKey = KSettingsVTStillImagePath;

                item.iUid = KCRUidTelephonySettings;

                break;

            case ECallTimer:

                item.iIntKey = KLogsShowCallDuration;

                item.iUid = KCRUidLogs;

                break;

            case EHandsetVolume:           

                item.iIntKey = KTelIncallEarVolume;

                item.iUid = KCRUidInCallVolume;

                break;

            case EHandsfreeVolume:

                item.iIntKey = KTelIncallLoudspeakerVolume;

                item.iUid = KCRUidInCallVolume;              

                break;

            default:

                break;

            }

        item.iObserver = &aObserver;

        iObserverItems->AppendL( item );

        }

        }

    __VTPRINTEXIT( "Settings.NotifyChangeL" )

    }

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

// CVtEngSettings::CancelNotifyChange

// Cancels receiving change events.

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

//

void CVtEngSettings::CancelNotifyChange( 

    TSettingId aId, const MVtEngSettingObserver& aObserver )

    {

    __VTPRINTENTER( "Settings.CancelNotifyChange" )

    if ( aId == ESelectVolume )

        {

        if ( &aObserver == iSelectVolumeObserver )

            {

            iSelectVolumeObserver = NULL;

            }

        }

    else if ( &aObserver == iDataportObserver )

        {

        iDataportObserver = NULL;

        // also free space used for dataport info

        delete iDataportInfo;

        iDataportInfo = NULL;

        }

    else

        {

        TInt count( iObserverItems->Count() );

        while ( count-- )

            {

            const TObserverItem& item = iObserverItems->At( count );

            if ( item.iId == aId &&

                item.iObserver == &aObserver )

                {

                iObserverItems->Delete( count );

                count = 0; // breaks loop

                }

            }

        }

    __VTPRINTEXIT( "Settings.CancelNotifyChange" )

    }

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

// CVtEngSettings::HandleNotifyInt

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

//

void CVtEngSettings::HandleNotifyInt( const TUid aUid, 

    const TUint32 aId, TInt aNewValue )

    {

    TBool informObserver = ETrue;       

    if ( aUid == KCRUidInCallVolume )   

        {

        switch ( aId )

            {

            case KTelIncallLoudspeakerVolume:

                {

                __VTPRINT( DEBUG_GEN, "Settings.HandleNotifyInt: HF volume" )

                if ( iConfig.iAudio.iVolume.iHandsfreeVolume == aNewValue )

                    {

                    informObserver = EFalse;

                    }

                else

                    {                

                    iConfig.iAudio.iVolume.iHandsfreeVolume = aNewValue;

                    }

                }

                break;

            case KTelIncallEarVolume:           

                {

                __VTPRINT( DEBUG_GEN, "Settings.HandleNotifyInt: HandsetVolume" )

                if ( iConfig.iAudio.iVolume.iHandsetVolume == aNewValue )

                    {

                    informObserver = EFalse;

                    }

                else

                    {

                    iConfig.iAudio.iVolume.iHandsetVolume = aNewValue;

                    }

                }

                break;

            default:

                __VTPRINT( DEBUG_GEN, "Settings.HandleNotifyInt: Non-ordered" );

                break;

            }

        }

    else if ( aUid == KCRUidLogs )

        {

        switch ( aId )

            {

            case KLogsShowCallDuration:

                {

                __VTPRINT( DEBUG_GEN, "Settings.HandleNotifyInt: call duration" )

                iConfig.iCallTimerOn = aNewValue > 0 ? ETrue : EFalse;

                }

                break;

            default:

                __VTPRINT( DEBUG_GEN, "Settings.HandleNotifyInt: Non-ordered" );

                break;