/*

* 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:    SIMPLE engine settings

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32base.h>

#include <centralrepository.h>

#include <pressettingsapi.h>

#include "simpleenginedomaincrkeys.h"

#include "simpleengineprivatecrkeys.h"

#ifdef _DEBUG

#include <bautils.h>

#include "simpledebugutils.h"

#endif

#include "simplesettings.h"

#ifdef _DEBUG

_LIT ( KSimpleIniFile, "\\system\\data\\simple.ini");

_LIT8 ( KSimpleExpiryPuhlish, "expiry_publish");

_LIT8 ( KSimpleExpiryWatcher, "expiry_watcher");

_LIT8 ( KSimpleExpiryWinfo, "expiry_winfo");

_LIT8 ( KSimpleExpiryAPI, "expiry_api");

_LIT8 ( KSimpleObjLimit, "obj_limit");

_LIT8 ( KSimpleThrottle, "throttle");

_LIT8 ( KSimpleMaxSubs, "max_subs");

#endif

/** default API expiry time */

const TInt KMyDefaultAPIExpiry = 60;

/** default SIP refresh expiry time */

const TInt KMyDefaultSIPExpiry = 43200;

/** default OTA settings value */

const TInt KOTASettingsDefault = 0;

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

//**********************************

// TSimpleSettings

//**********************************

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

// TSimpleSettings::TSimpleSettings

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

//

TSimpleSettings::TSimpleSettings( )

    :

    iExpiryPuhlish( KMyDefaultSIPExpiry ),

    iExpiryWatcher( KMyDefaultSIPExpiry ),

    iExpiryWinfo( KMyDefaultSIPExpiry ),

    iExpiryApi( KMyDefaultAPIExpiry ),

    iObjLimit(KOTASettingsDefault),

    iThrottle(KOTASettingsDefault),

    iMaxSubscriptions(KOTASettingsDefault),

    iSipProfileId(KOTASettingsDefault)

    {}

TUint TSimpleSettings::ExpiryPuhlish()

    {

    return iExpiryPuhlish;

    }

TUint TSimpleSettings::ExpiryWatcher()

    {

    return iExpiryWatcher;

    }

TUint TSimpleSettings::ExpiryWinfo()

    {

    return iExpiryWinfo;

    }

TUint TSimpleSettings::ExpiryApi()

    {

    return iExpiryApi;

    }

TInt TSimpleSettings::ObjLimit()

    {

    return iObjLimit;

    }

TInt TSimpleSettings::Throttle()

    {

    return iThrottle;

    }

TInt TSimpleSettings::MaxSubscriptions()

    {

    return iMaxSubscriptions;

    }

TInt TSimpleSettings::SipProfileId()

    {

    return iSipProfileId;

    }

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

// TSimpleSettings::ReadCentRepSettings

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

//

void TSimpleSettings::ReadCentRepSettings( )

    {

    // Read Central Repository settings

    CRepository* repository = NULL;

    TRAP_IGNORE( repository = CRepository::NewL( KCRUIDSimpleVariation ));

    if ( repository )

        {

        //TRAP_IGNORE( iExpiryPuhlish = GetCenRepIntValueL(

        //    repository, KSimplePublishRefresh ));

        TRAP_IGNORE( iExpiryWatcher = GetCenRepIntValueL(

            repository, KSimpleSubscribeRefresh ));

        TRAP_IGNORE( iExpiryWinfo = GetCenRepIntValueL(

            repository, KSimpleSubscribeWinfoRefresh ));

        TRAP_IGNORE( iExpiryApi = GetCenRepIntValueL(

            repository, KSimpleExpiryTime));

        delete repository;

        repository = NULL;

#ifdef _DEBUG

#ifdef __WINS__

        TSimpleLogger::Log(_L("CentRep iExpiryPuhlish=%d iExpiryWatcher=%d iExpiryWinfo=%d iExpiryAPI=%d"),

        iExpiryPuhlish, iExpiryWatcher, iExpiryWinfo, iExpiryApi);

#endif

#endif

        }

    }

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

// TSimpleSettings::ReadOTASettings

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

//

void TSimpleSettings::ReadOTASettingsL( TInt aSetId )

    {

    // Read OTA settings using PresSettingsApi

    TPresSettingsSet set;

    TInt error( KErrNone );

    error = PresSettingsApi::SettingsSetL( aSetId, set );

    User::LeaveIfError( error );

    // convert -1 values (undefined) to default values

    iObjLimit = set.iObjectSize > KOTASettingsDefault ?

        set.iObjectSize : KOTASettingsDefault;

    iMaxSubscriptions = set.iMaxSubscriptions > KOTASettingsDefault ?

        set.iMaxSubscriptions : KOTASettingsDefault;

    iThrottle = set.iPublicationInt > KOTASettingsDefault ?

        set.iPublicationInt : KOTASettingsDefault;

    iSipProfileId = set.iSipProfile > KOTASettingsDefault ?

        set.iSipProfile : KOTASettingsDefault;

#ifdef _DEBUG

#ifdef __WINS__

        TSimpleLogger::Log(_L("OTAsettings iObjLimit=%d iThrottle=%d iMaxSubs=%d iSip=%d"),

        iObjLimit, iThrottle, iMaxSubscriptions, iSipProfileId );

#endif

#endif

    }

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

// TSimpleSettings:GetCenRepIntValueL

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

//

TInt TSimpleSettings::GetCenRepIntValueL(

    CRepository* aRepository,

    TUint32 aId )

    {

    TInt value( 0 );

    User::LeaveIfError( aRepository->Get( aId, value ) );

    return value;

    }

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

// TSimpleSettings::ReadIniFileL

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

//

#ifdef _DEBUG

void TSimpleSettings::ReadIniFileL( RFs&  aFs )

    {

    // Set few values without reading them from ini file

    CSimpleSettingFile* configFile = CSimpleSettingFile::NewL( aFs );

    CleanupStack::PushL( configFile );  // *****

    // Search current drive

    TFileName path;

    Dll::FileName( path );

    TDriveName drive( TParsePtrC( path ).Drive( ) );

    // In emulator we try to find from c drive

    // in hardware we try to find from current drive and then from RAM.

#ifdef __WINS__

    TFileName fileN( KSimpleIniFile);

#else

    TFileName fileN( drive );

    fileN.Append( KSimpleIniFile );

#endif

    TInt err = 0;

    // Open temporary config file

    TRAP( err, configFile->OpenL( fileN ));

    if ( err && drive.CompareF( _L("c:") ))

        {

        err = KErrNone;

        fileN = _L("c:");

        fileN.Append( KSimpleIniFile );

        TRAP( err, configFile->OpenL( fileN ));

        }

    if ( err )

        {

        err = KErrNone;

        TSimpleLogger::Log(_L("Config file not found ***"));

        User::Leave( KErrNotFound );

        }

    else

        {

        TSimpleLogger::Log(_L("Config file found ***"));

        }

    TUint32 myUint = 0;

    TPtrC8 myPtr;

    TBuf<8> myBuffer;

    // read expiry times

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryPuhlish)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iExpiryPuhlish = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryWatcher)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iExpiryWatcher = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryWinfo)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iExpiryWinfo = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleExpiryAPI)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iExpiryApi = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleObjLimit)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iObjLimit = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleThrottle)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iThrottle = (TInt) myUint;

        }

    TRAP( err, myPtr.Set( configFile->KeyValueL(KSimpleMaxSubs)));

    if ( !err )

        {

        myBuffer.Copy( myPtr );

        TLex lex;

        lex.Assign( myBuffer );

        lex.Val(myUint, EDecimal);

        iMaxSubscriptions = (TInt) myUint;

        }

    CleanupStack::PopAndDestroy(configFile);

    // debug logging

    TSimpleLogger::Log(_L("ReadFile iExpiryPuhlish=%d iExpiryWatcher=%d iExpiryWinfo=%d iExpiryAPI=%d"),

    iExpiryPuhlish, iExpiryWatcher, iExpiryWinfo, iExpiryApi);

    TSimpleLogger::Log(_L("ReadFile iObjLimit=%d iThrottle=%d iMaxSubs=%d"),

    iObjLimit, iThrottle, iMaxSubscriptions );

    }

#endif // _DEBUG

//  End of File