/*

* Copyright (c) 2002-2005 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:  Settings manager

*

*/

// INCLUDE FILES

#include "CCASettingsManager.h"			// Own header

#include "MCASettingsObserver.h"

#include "ChatDebugPrint.h"

#include "chatdebugassert.h"

#include "PrivateEngineDefinitions.h"

#include "CCASDCRVariator.h"

#include "ImpsCSPAllErrors.h"

#include "impsbuilddefinitions.h"

#include <e32base.h>

#include <CIMPSSAPSettingsStore.h>

#include <CIMPSSAPSettings.h>

#include <CIMPSSAPSettingsList.h>

#include <centralrepository.h>

// CONSTANTS

// Separators for Alias table, to separate items from each other

// e.g [userid][itemsep][alias][tablesep][userid][itemsep][alias] etc...

//

const TUint KAliasItemSeparator  = 0x10;

const TUint KAliasTableSeparator = 0x11;

const TInt  KSeparatorSize       = 2; // bytes

// Maximum length for alias table.

// See CIMPSSAPSettings::SetOpaqueDesC16 for description of this value

const TInt  KMaxAliasDataLength  =

    NCentralRepositoryConstants::KMaxUnicodeStringLength -

    5 - 10; // 10 == KCAOwnAlias().Length() !

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

// Two-phased constructor.

CCASettingsManager* CCASettingsManager::NewL( TUid aIdentifier )

    {

    CCASettingsManager* self = new ( ELeave ) CCASettingsManager;

    CleanupStack::PushL( self );

    self->ConstructL( aIdentifier );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCASettingsManager::~CCASettingsManager()

    {

    iObserverList.Close();

    delete iSDCRVariator;

    delete iSapSettingsStore;

    delete iDefaultSap;

    }

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

// CCASettingsManager::AddObserverL

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

//

void CCASettingsManager::AddObserverL( const MCASettingsObserver* aObserver )

    {

    if ( aObserver )

        {

        TInt err( iObserverList.Append( aObserver ) );

        User::LeaveIfError( err );

        }

    }

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

// CCASettingsManager::RemoveObserver

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

//

void CCASettingsManager::RemoveObserver( const MCASettingsObserver* aObserver )

    {

    TInt index( iObserverList.Find( aObserver ) );

    if ( index != KErrNotFound )

        {

        iObserverList.Remove( index );

        }

    }

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

// CCASettingsManager::Value

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

//

TBool CCASettingsManager::Value( TCASettingFlags aSetting,

                                 CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TInt value( 0 );

    TBool ok( EFalse );

    TRAPD( err,

        {

        CIMPSSAPSettings* sap = GetSAPLC( aSap );

        if ( iSettingsFaceLift && !sap )

            {

            ok = ( iSDCRVariator->GetInt( aSetting, value ) == KErrNone );

            }

        else if ( sap )

            {

            TPtrC settingName( ConvertSettingInteger( aSetting ) );

            if ( settingName.Length() > 0 )

                {

                ok = ( sap->GetOpaqueInt( settingName, value ) == KErrNone );

                }

            }

        if ( !ok )

            {

            if ( iSDCRVariator->GetInt( aSetting, value ) != KErrNone )

                {

                value = DefaultBooleanValue( aSetting );

                }

            }

        CleanupStack::PopAndDestroy( sap );

        CHAT_DP( D_CHAT_LIT( "CCASettingsManager::Value( %d ) = %d" ),

                 aSetting, value );

        } );    // TRAPD

    if ( err )

        {

        CActiveScheduler::Current()->Error( err );

        return EFalse;

        }

    else

        {

        return value;

        }

    }

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

// CCASettingsManager::Value

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

//

TInt CCASettingsManager::Value( TCASettingIntegers aSetting,

                                CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TInt value( 0 );

    TBool ok( EFalse );

    TRAPD( err,

        {

        CIMPSSAPSettings* sap = GetSAPLC( aSap );

        if ( iSettingsFaceLift && !sap )

            {

            ok = ( iSDCRVariator->GetInt( aSetting, value ) == KErrNone );

            }

        else if ( sap )

            {

            TPtrC settingName( ConvertSettingInteger( aSetting ) );

            if ( settingName.Length() > 0 )

                {

                ok = ( sap->GetOpaqueInt( ConvertSettingInteger( aSetting ), value ) == KErrNone );

                }

            }

        if ( !ok )

            {

            if ( iSDCRVariator->GetInt( aSetting, value ) != KErrNone )

                {

                value = DefaultIntegerValue( aSetting );

                }

            }

        CleanupStack::PopAndDestroy( sap );

        CHAT_DP( D_CHAT_LIT( "CCASettingsManager::Value( %d ) = %d" ),

                 aSetting, value );

        } );    // TRAPD

    if ( err )

        {

        CActiveScheduler::Current()->Error( err );

        return EFalse;

        }

    else

        {

        return value;

        }

    }

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

// CCASettingsManager::ValueL

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

//

HBufC* CCASettingsManager::ValueL( TCASettingStrings aSetting,

                                   CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TInt length( ( aSetting & EStringsLengthMask ) >> EStringsLengthShift );

    // Check if those enum definitions where reasonable

    if ( !length )

        {

        User::Leave( EInvalidStringEnumDefinition );

        }

    HBufC* temp = HBufC::NewLC( length );

    TPtr str( temp->Des() );

    CIMPSSAPSettings* sap = GetSAPLC( aSap );

    TInt ok( EFalse );

    if ( sap )

        {

        TPtrC settingName( ConvertSettingInteger( aSetting ) );

        if ( settingName.Length() > 0 )

            {

            TPtrC strC( KNullDesC );

            ok = ( sap->GetOpaqueDesC16( settingName, strC ) == KErrNone );

            str.Copy( strC );

            }

        }

    if ( !ok )

        {

        if ( iSDCRVariator->GetString( aSetting, str ) != KErrNone )

            {

            // default to empty

            str.Copy( KNullDesC );

            }

        }

    CHAT_DP( D_CHAT_LIT( "CCASettingsManager::Value( %d ) = %S" ),

             aSetting, temp );

    CleanupStack::PopAndDestroy( sap );

    CleanupStack::Pop( temp );

    return temp;

    }

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

// CCASettingsManager::SetValueL

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

//

void CCASettingsManager::SetValueL( TCASettingFlags aSetting, TBool aValue,

                                    RArray<TInt>* aIgnoreRollback /*= NULL*/,

                                    CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TBool oldValue( Value( aSetting, aSap ) );

    SetIntValueL( aSetting, aValue, oldValue, aIgnoreRollback, aSap );

    }

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

// CCASettingsManager::SetValueL

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

//

void CCASettingsManager::SetValueL( TCASettingIntegers aSetting, TInt aValue,

                                    RArray<TInt>* aIgnoreRollback /*= NULL*/,

                                    CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TInt oldValue( Value( aSetting, aSap ) );

    SetIntValueL( aSetting, aValue, oldValue, aIgnoreRollback, aSap );

    }

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

// CCASettingsManager::SetIntValueL

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

//

void CCASettingsManager::SetIntValueL( TInt aSetting, TInt aValue,

                                       TInt aOldValue,

                                       RArray<TInt>* aIgnoreRollback /*= NULL*/,

                                       CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    if ( aValue != aOldValue )

        {

        CIMPSSAPSettings* sap = GetSAPLC( aSap );

        StoreL( sap, aSetting, aValue );

        TInt leave( KErrNone );

        TRAP( leave, NotifyObserversL( aSetting ) );

        if ( leave )

            {

            //roll back

            TBool rollback( ETrue );

            if ( aIgnoreRollback )

                {

                // rollback if the error code is not found from the list

                rollback = ( aIgnoreRollback->Find( leave ) == KErrNotFound );

                }

            if ( rollback )

                {

                StoreL( sap, aSetting, aOldValue );

                }

            User::Leave( leave );

            }

        CleanupStack::PopAndDestroy( sap );

        }

    }

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

// CCASettingsManager::SetValueL

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

//

void CCASettingsManager::SetValueL( TCASettingStrings aSetting,

                                    const TDesC& aValue,

                                    RArray<TInt>* aIgnoreRollback /*= NULL*/,

                                    CIMPSSAPSettings* aSap /*= NULL*/ )

    {

    TInt length( ( aSetting & EStringsLengthMask ) >> EStringsLengthShift );

    if ( length < aValue.Length() )

        {

        User::Leave( EStringTooLong );

        }

    HBufC* oldValue = NULL;

    TRAPD( err, oldValue = ValueL( aSetting ) );

    if ( err != EOwnUserIdNotAvailable )

        {

        User::LeaveIfError( err );

        }

    if ( oldValue )

        {

        CleanupStack::PushL( oldValue );

        }

    if ( !oldValue || aValue != *oldValue )

        {

        CHAT_DP( D_CHAT_LIT( "CCASettingsManager::Value( %d ) = %S" ),

                 aSetting, &aValue );

        CIMPSSAPSettings* sap = GetSAPLC( aSap );

        StoreL( sap, aSetting, aValue );

        TInt leave( KErrNone );

        TRAP( leave, NotifyObserversL( aSetting ) );

        if ( leave && oldValue )

            {

            //roll back

            TBool rollback( ETrue );

            if ( aIgnoreRollback )

                {

                // rollback if the error code is not found from the list

                rollback = ( aIgnoreRollback->Find( leave ) == KErrNotFound );

                }

            if ( rollback )

                {

                StoreL( sap, aSetting, *oldValue );

                }

            }

        User::LeaveIfError( leave );

        CleanupStack::PopAndDestroy( sap );

        }

    if ( oldValue )

        {

        CleanupStack::PopAndDestroy( oldValue );

        }

    }

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

// CCASettingsManager::FlushData

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

//

void CCASettingsManager::FlushData()

    {

    TInt err = iSDCRVariator->FlushData();

    if ( err != KErrNone )

        {

        CActiveScheduler::Current()->Error( err );

        }

    }

// Symbian OS default constructor can leave.

void CCASettingsManager::ConstructL( TUid aIdentifier )

    {

    iSDCRVariator = CCASDCRVariator::NewL( aIdentifier );

    iSapSettingsStore = CIMPSSAPSettingsStore::NewL();

    // populate the list of sapsettings

    CIMPSSAPSettingsList* sapList = CIMPSSAPSettingsList::NewLC();

    iSapSettingsStore->PopulateSAPSettingsListL( *sapList, EIMPSIMAccessGroup );

    CIMPSSAPSettings* sap = CIMPSSAPSettings::NewLC();

    TRAPD( err, iSapSettingsStore->GetDefaultL( sap, EIMPSIMAccessGroup ) );

    if ( err == KErrNotFound )

        {

        CleanupStack::PopAndDestroy( sap );

        sap = NULL;

        }

    else

        {

        CleanupStack::Pop( sap );

        }

    iDefaultSap = sap;

    CleanupStack::PopAndDestroy( sapList );

#ifdef RD_SETTINGS_FACELIFT

    iSettingsFaceLift = ETrue;

#endif

    }

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

// might leave.

//

CCASettingsManager::CCASettingsManager()

    {

    }

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

// CCASettingsManager::NotifyObserversL

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

//

void CCASettingsManager::NotifyObserversL( TInt aEnum )

    {

    TInt observerCount( iObserverList.Count() );

    CHAT_DP( D_CHAT_LIT( "CCASettingsManager::NotifyObserversL(%d), changed \

	                      enum: %d" ), observerCount, aEnum );

    for ( TInt i( 0 ); i < observerCount; ++i )

        {

        ( *iObserverList[i] ).HandleSettingsChangeL( aEnum );

        }

    }

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

// CCASettingsManager::DefaultIntegerValue

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

//

TInt CCASettingsManager::DefaultIntegerValue( TInt aEnum ) const

    {

    switch ( aEnum )

        {

        case EMessageFlowSettingLevel:

            {

            return KDefaultMessageFlowSettingLevel;

            }

        case EFriendsListOrdering :

            {

            return EAlphabetical;

            }

        default:

            {

            // Default default value will be zero for integers

            return 0;

            }

        }

    }

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

// CCASettingsManager::DefaultBooleanValue

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

//

TBool CCASettingsManager::DefaultBooleanValue( TInt aEnum ) const

    {

    switch ( aEnum )

        {

        case EFirstLoginDone:

            {

            return KDefaultFirstLoginDone;

            }

        case EDefaultScreenNameInUse:

            {

            return KDefaultDefaultScreenNameInUse;

            }

        case EAutomaticPresenceUpdate:

            {

            return KDefaultAutomaticPresenceUpdate;

            }

        case EUpdateSelectedContacts:

            {

            return KDefaultUpdateSelectedContacts;

            }

        case EShowHistory:

            {

            return KDefaultShowHistory;

            }

        case EShowOffline:

            {

            return KDefaultShowOffline;

            }

        case EShowTimeStamps:

            {

            return KDefaultShowTimeStamps;

            }

        default:

            {

            return EFalse;

            }

        }

    }

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

// CCASettingsManager::ConvertSettingInteger

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

//

const TDesC& CCASettingsManager::ConvertSettingInteger( TInt aEnum ) const

    {

    switch ( aEnum )

        {

            // TCASettingFlags

        case EFirstLoginDone:

            {

            return KCAFirstLoginDone();

            }

        case EDefaultScreenNameInUse:

            {

            return KCADefaultScreenNameInUse();