/*

* Copyright (c) 2002-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:  Control for accessory related settings.

*

*/

// INCLUDE FILES

#include "AccSrvSettingsHandler.h"

#include "AccSrvConnectionController.h"

#include "acc_debug.h"

#include <AccessoryTypes.h>

#include <e32property.h>

#include <centralrepository.h>

#include <hwrmdomainpskeys.h>

#include <AccSettingsDomainCRKeys.h>

#include <f32file.h>

#include <hwrmlight.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KAccSettingIdLength = 4; // "int:" or "boo:" or "des:"

const TInt KAccSettingMaxLength = KAccSettingIdLength + KMaxAccModeSetting;

// Max size in bytes for hwdevices.ini file

const TInt KHWDevicesFileMaxSize = 4;

// Maximum number of supported accessory modes

const TInt KMaxAccessoryMode = 4096;

// Maximum number of supported settings for each accessory mode

const TInt KMaxAccessorySetting = 4096;

// First bit reserved for accessory mode when counting is started from right

const TInt KAccessoryModeStartBit = 20;

// First bit reserved for accessory mode setting when counting is started from

// right

const TInt KAccessoryModeSettingStartBit = 8;

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT( KAccSettingInteger, "int:" );

_LIT( KAccSettingBoolean, "boo:" );

_LIT( KAccSettingDescriptor, "des:" );

// File that stores supported HW devices

_LIT( KHWDevicesFile, "c:\\private\\1020504A\\hwdevices.ini" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CAccSrvSettingsHandler::CAccSrvSettingsHandler

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

// might leave.

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

//

CAccSrvSettingsHandler::CAccSrvSettingsHandler( CAccSrvConnectionController* aConCtrl,

                                                CAccSrvServerModel& aModel )

    : iConCtrl( aConCtrl ),

      iModel( aModel ),

      iLightsOn( EAccSettingsLightsNotSet )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::CAccSrvSettingsHandler()" );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::CAccSrvSettingsHandler - return" );

    }

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

// CAccSrvSettingsHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAccSrvSettingsHandler::ConstructL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConstructL()" );

    // Update settings in model according to CR

    TInt retval( KErrNone );

    TInt hwDevices( 0 );

    retval = RProperty::Define( KPSUidHWRM,

                                KHWRMAccessoryVibraBlocked, 

                                RProperty::EInt, 

                                KNoCapability, 

                                KWriteDeviceDataPolicy);

    if( retval != KErrAlreadyExists )

        {

        User::LeaveIfError( retval );   

        }

    CRepository* repository = CRepository::NewLC( KCRUidAccServer );

    User::LeaveIfError( repository->Get( KAccServerHWDevices, hwDevices ) );

    iModel.SetDeviceType( static_cast<TUint32>( hwDevices ) );

    CleanupStack::PopAndDestroy( repository );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConstructL - return void" );

    }

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

// CAccSrvSettingsHandler::NewL

// Two-phased constructor.

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

//

CAccSrvSettingsHandler* CAccSrvSettingsHandler::NewL(

                                           CAccSrvConnectionController* aConCtrl,

                                           CAccSrvServerModel& aModel )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::NewL()" );

    CAccSrvSettingsHandler* self = new( ELeave ) CAccSrvSettingsHandler(

                                                    aConCtrl,

                                                    aModel );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::NewL - return self" );

    return self;

    }

// Destructor

CAccSrvSettingsHandler::~CAccSrvSettingsHandler()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::~CAccSrvSettingsHandler()" );

    delete iLightsApi;

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::~CAccSrvSettingsHandler - return" );

    }

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

// CAccSrvSettingsHandler::ConnectionStatusChangedL

// Accessory settings may change when connection status changes. This method

// updates settings according connection status and user given settings.

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::ConnectionStatusChangedL(

    TAccPolGenericIDArray& aArray )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConnectionStatusChangedL()" );

    TAccPolGenericID genericId;

    TBool vibraAllowed( ETrue );

    // Any accessories connected

    if( aArray.Count() > 0 )

        {

        // get generic id of last connected accessory

        genericId = aArray.GetGenericIDL( 0 );

        // check if vibra is really allowed

        GetVibraAllowed( genericId, vibraAllowed );

        }

    // Get current vibra status

    TInt vibraBlocked( 0 );

    RProperty::Get( KPSUidHWRM, KHWRMAccessoryVibraBlocked, vibraBlocked );

    // Set vibra on/off, if needed

    if( !vibraAllowed && vibraBlocked == 0 )

        {

        // accessory that doesn't support vibra was connected -> set vibra of

        COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandlerConnectionStatusChangedL() - Vibra PS Key = VibraOff" );

        RProperty::Set( KPSUidHWRM,

                        KHWRMAccessoryVibraBlocked,

                        1 );

        }

    else if( vibraAllowed && vibraBlocked == 1 )

        {

        // accessory that doesn't support vibra was disconnected -> set vibra on

        COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandlerConnectionStatusChangedL() - Vibra PS Key = VibraOn" );

        RProperty::Set( KPSUidHWRM,

                        KHWRMAccessoryVibraBlocked,

                        0 );

        }

    TBool setLights( EFalse );

    // Accessory connected

    if( aArray.Count() > 0 )

        {

        // check if lights should be put on

        GetLightsAllowedL( genericId, setLights );

        // Need to set lights on

        if( setLights )

            {

            // accessory with lights on setting connected -> set lights on

            COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConnectionStatusChangedL() - Set lights on" );

            if( !iLightsApi )

                {

                iLightsApi = CHWRMLight::NewL();

                }

            iLightsApi->ReserveLightL( CHWRMLight::ESystemTarget, ETrue, ETrue );

            iLightsApi->LightOnL( CHWRMLight::ESystemTarget );

            iLightsOn = EAccSettingsLightsOn;

            }

        }

    else if( iLightsOn == EAccSettingsLightsOn )

        {

        // accessory with lights on setting disconnected -> set lights off

        COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConnectionStatusChangedL() - Set lights off" );

        iLightsApi->ReleaseLight( CHWRMLight::ESystemTarget );

        delete iLightsApi;

        iLightsApi = NULL;

        iLightsOn = EAccSettingsLightsOff;

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::ConnectionStatusChangedL() - return void" );

    }

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

// CAccSrvSettingsHandler::GetSupportedHWDevicesL

//

// (other items were commented in a header).

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

//

TUint32 CAccSrvSettingsHandler::GetSupportedHWDevicesL() const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::GetSupportedHWDevicesL()" );

    TUint32 settings( 0 );

    // Read supported HW devices from file

    RFs session;

    RFile file;

    HBufC8* buf = HBufC8::NewL( KHWDevicesFileMaxSize );

    CleanupStack::PushL( buf );

    TPtr8 ptrBuf( buf->Des() );

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

	CleanupClosePushL ( session );

    User::LeaveIfError( file.Open( session, KHWDevicesFile, EFileRead ) );

    file.Read( ptrBuf );

    file.Close();

    TLex8 l( ptrBuf );

    TInt32 temp;

    l.Val( temp );

    settings = static_cast< TUint32 >( temp );

	CleanupStack::PopAndDestroy ( &session );

    CleanupStack::PopAndDestroy ( buf );

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::GetSupportedHWDevicesL() - return %d", settings );

    return settings;

    }

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

// CAccSrvSettingsHandler::SetHWDeviceSettingsL

//

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::SetHWDeviceSettingsL( TUint32 aSettings,

                                                   TBool aEnable,

                                                   TBool aForce  ) const

    {

    COM_TRACE_3( "[AccFW:AccServer] CAccSrvSettingsHandler::SetHWDeviceSettingsL( %d, %d, %d  )", aSettings, aEnable, aForce );

    // Valid settings

    TUint32 settings = ResolveNewSettingsL( aSettings, aEnable, aForce );

    // Update model

    iModel.SetDeviceType( settings );

    // Update setting to CR

    CRepository* repository = CRepository::NewL( KCRUidAccServer );

    TInt crSettings = static_cast<TInt>( settings );

    repository->Set( KAccServerHWDevices, crSettings );

    delete repository;

    repository = NULL;

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::SetHWDeviceSettingsL() - return" );

    }

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

// CAccSrvSettingsHandler::GetHWDeviceSettings

//

// (other items were commented in a header).

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

//

TUint32 CAccSrvSettingsHandler::GetHWDeviceSettings() const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::GetHWDeviceSettings()" );

    TUint32 settings = iModel.DeviceType();

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::SetHWDeviceSettings() - return %d", settings );

    return settings;

    }

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

// CAccSrvSettingsHandler::SetAccessoryModeSettingL

//

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::SetAccessoryModeSettingL(

                                        const TAccMode aAccMode,

                                        const TAccModeSetting& aSetting ) const

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::SetAccessoryModeSettingL()" );

    CRepository* repository = CRepository::NewL( KCRUidAccServer );

    CleanupStack::PushL( repository );

    // Static or dynamic setting

    if( StaticKey( aSetting.Id() ) )

        {

        // write INT setting to CR

        TUint32 key = static_cast<TUint32>( aSetting.Id() );

        TInt setting( 0 );

        aSetting.GetTInt( setting );

        User::LeaveIfError( repository->Set( key, setting ) );

        }

    else

        {

        // write DESCRIPTOR setting to CR

        TUint32 key = CreateCRKeyL( aAccMode, aSetting.Id() );

        HBufC* setting = CodeSettingL( aSetting );

        CleanupStack::PushL( setting );

        User::LeaveIfError( repository->Set( key, *setting ) );

        CleanupStack::PopAndDestroy( setting );

        }

    CleanupStack::PopAndDestroy( repository );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::SetAccessoryModeSettingL() - return" );

    }

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

// CAccSrvSettingsHandler::GetAccessoryModeSettingL

//

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::GetAccessoryModeSettingL(

                                        const TAccMode aAccMode,

                                        TAccModeSetting& aSetting ) const

    {

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::GetAccessoryModeSettingL() AccMode=%d", aAccMode );

    CRepository* repository = CRepository::NewL( KCRUidAccServer );

    CleanupStack::PushL( repository );

    // static / dynamic key

    if( StaticKey( aSetting.Id() ) )

        {

        // read INT setting from CR

        TUint32 key = static_cast<TUint32>( aSetting.Id() );

        TInt setting( 0 );

        User::LeaveIfError( repository->Get( key, setting ) );

        aSetting.SetTInt( setting );

        }

    else

        {

        // read DESCRIPTOR setting from CR

        TUint32 key = CreateCRKeyL( aAccMode, aSetting.Id() );

        TBuf16< KAccSettingMaxLength > setting;

        User::LeaveIfError( repository->Get( key, setting ) );

        DecodeSettingL( setting, aSetting );

        }

    CleanupStack::PopAndDestroy( repository );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::GetAccessoryModeSettingL() - return" );

    }

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

// CAccSrvSettingsHandler::SetAccessoryModeSettingsL

//

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::SetAccessoryModeSettingsL(

    const TAccMode aAccMode,

    const TAccModeSettingArray& aArray ) const

    {

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::SetAccessoryModeSettingsL(aAccMode=%d)", aAccMode );

    for(TInt i=0; i<aArray.GetArraySize(); ++i )

        {

        TAccModeSetting setting;

        aArray.GetSetting( i, setting );

        SetAccessoryModeSettingL( aAccMode, setting );

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::SetAccessoryModeSettingsL() - return" );

    }

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

// CAccSrvSettingsHandler::GetAccessoryModeSettingsL

//

// (other items were commented in a header).

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

//

void CAccSrvSettingsHandler::GetAccessoryModeSettingsL(

    const TAccMode aAccMode,

    TAccModeSettingArray& aArray ) const

    {

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::GetAccessoryModeSettingsL(aAccMode=%d)", aAccMode );

    // Creation of partialKey and mask below has to be line with logic in

    // CAccSrvSettingsHandler::CreateCRKeyL() method.

    TUint32 mode = static_cast< TUint32 >( const_cast< TAccMode& >( aAccMode ) );

    if( mode >= KMaxAccessoryMode )

        {

        // mode value is out of range

        COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::GetAccessoryModeSettingsL() aAccMode=%d is out of range", aAccMode );

        User::Leave( KErrArgument );

        }

	// reset possible items in an array

	aArray.Reset();

	CRepository* repository = CRepository::NewL( KCRUidAccServer );

    CleanupStack::PushL( repository );

    // search accessory mode specific dynamic settings

    RArray< TUint32 > foundKeys;

    CleanupClosePushL( foundKeys );

    TUint32 partialKey = mode << KAccessoryModeStartBit;

    TUint32 mask( 0xfff00000 );

    repository->FindL( partialKey, mask, foundKeys );	

	RArray< TUint32 > array;

	CleanupClosePushL( array );

  	TAccModeSetting setting;

    // get mode related static settings for client

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

    	{

      	TInt intSetting( 0 );

      	User::LeaveIfError( repository->Get( array[i], intSetting ) );

      	setting.SetId( array[i] );

      	setting.SetTInt( intSetting ); // sets type & value

      	aArray.AddSetting( setting );

      	}

    // get mode related dynamic settings

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

    	{

      	TUint32 key = foundKeys[i];

      	TBuf16< KAccSettingMaxLength > desSetting;

      	User::LeaveIfError( repository->Get( key, desSetting ) );

      	// setting id is stored key's to hexadecimal numbers marked with X:

    	// 0x000XXX00

    	TUint32 temp = key & 0x000fff00;

    	TUint32 id = temp >> KAccessoryModeSettingStartBit;

    	setting.SetId( id );

    	DecodeSettingL( desSetting, setting ); // sets type & value

    	aArray.AddSetting( setting );

    	}

	CleanupStack::PopAndDestroy( &array );//array.Close() is called;

	CleanupStack::PopAndDestroy( &foundKeys );//foundKeys.Close() is called;

    CleanupStack::PopAndDestroy( repository );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvSettingsHandler::GetAccessoryModeSettingsL() - return" );

    }

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

// CAccSrvSettingsHandler::ResolveNewSettingsL

// Note: This method assumes that only ONE HW DEVICE setting is ACTIVE AT THE

// TIME. If API method RAccessorySettings::SetHWDeviceSettingsL(

//                          TUint32 aSettings,

//                                                  TBool aEnable,

//                                                  TBool aForce )

//

// starts to support several active settings at the same time, this method

// has to be modified.

// (other items were commented in a header).

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

//

TUint32 CAccSrvSettingsHandler::ResolveNewSettingsL( TUint32 aSettings,

                                                     TBool aEnable,

                                                     TBool /*aForce*/  ) const

    {

    COM_TRACE_2( "[AccFW:AccServer] CAccSrvSettingsHandler::ResolveNewSettingsL( %d, %d )", aSettings, aEnable );

    TUint32 settings( 0 );

    // Clear all settings

    if( aSettings == KASNoDevice || !aEnable )

        {

        COM_TRACE_1( "[AccFW:AccServer] CAccSrvSettingsHandler::ResolveNewSettingsL() - return %d", settings );

        return settings;

        }

    // Set new setting

    switch ( aSettings )

        {

        case KASTTY:

        case KASLoopset:

		    case KASHeadset:

		    case KASHeadphones:

		    case KASLineOut:

		    case KASTVOut: