/*
* 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:  Class keeps BS configuration
 *
*/


#include <bautils.h> //FileExists
#include <xcfwtree.h>
#include <xcfwengine.h>
#include <gecoobjectbase.h>
#include <gecodefaultobject.h>

#include "bsdebug.h"
#include "bsconfiguration.h"

_LIT(KConfigurationFile, "bs_config.xml" );
_LIT(KCDrive, "C");
_LIT(KZDrive, "Z");

_LIT(KDelimiter, ":");
_LIT(KTrueValue, "1");
_LIT(KHexStart,"0x");

_LIT(KAppNode, "app");

_LIT(KUidAttribute, "uid");
_LIT(KResetAttribute, "reset");
_LIT(KIgnoredAttribute, "ignored");
_LIT(KIgnoredIfStartedFromAttribute, "ignoredIfStartedFrom");
_LIT(KResetIfThruAttribute, "resetIfThru");

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

// -----------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CBSConfiguration::CBSConfiguration()
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
//
CBSConfiguration::~CBSConfiguration()
    {
    delete iContentTree;
    delete iContentEngine;

    iResetApps.Close( );
    iIgnoredApps.Close( );
    iIgnoredIfStartedFrom.Close( );
    iResetIfThru.Close( );
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBSConfiguration* CBSConfiguration::NewLC()
    {
    CBSConfiguration* self = new (ELeave)CBSConfiguration();
    CleanupStack::PushL( self );
    self->ConstructL( );
    return self;
    }

// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBSConfiguration* CBSConfiguration::NewL()
    {
    CBSConfiguration* self = CBSConfiguration::NewLC( );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CBSConfiguration::ConstructL()
    {
    iContentTree = CXCFWTree::NewL( );
    iContentEngine = CXCFWEngine::NewL( this );

    RFs fileSession;

    User::LeaveIfError( fileSession.Connect( ) );
    CleanupClosePushL( fileSession );

    TFileName configPath;

    User::LeaveIfError( fileSession.PrivatePath( configPath ) );
    configPath.Insert( 0, KDelimiter );
    configPath.Insert( 0, KCDrive );
    configPath.Append( KConfigurationFile );

    // first check if file exists on c drive 
    if ( !BaflUtils::FileExists( fileSession, configPath ) )
        {
        // read from z drive 
        configPath[0] = KZDrive()[0];
        }

    CleanupStack::PopAndDestroy( &fileSession );

    iContentEngine->LoadL( *iContentTree, configPath );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//    
TBool CBSConfiguration::IsReset( TUid aApp )
    {
    return iResetApps.Find( aApp.iUid ) != KErrNotFound;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//        
TBool CBSConfiguration::IsIgnored( TUid aApp )
    {
    return iIgnoredApps.Find( aApp.iUid ) != KErrNotFound;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//        
TBool CBSConfiguration::IsIgnoredIfStartedFrom( TUid aApp )
    {
    return iIgnoredIfStartedFrom.Find( aApp.iUid ) != KErrNotFound;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//        
RArray<TInt>& CBSConfiguration::ResetIfThruList()
    {
    return iResetIfThru;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CBSConfiguration::LoadConfigurationL()
    {
    // get root node
    MXCFWNode* root = iContentTree->Root( );

    // list of fetched nodes
    RNodeArray nodes;
    CleanupClosePushL( nodes );

    // handle entries
    iContentTree->GetNodesOfTypeL( KAppNode, nodes, root, ETrue );

    for ( TInt i = 0; i < nodes.Count( ); i++ )
        {
        CGECODefaultObject* object =
                static_cast<CGECODefaultObject*>(nodes[i]->Data( ));
        TPtrC uidVal;
        TPtrC resetVal;
        TPtrC ignoredVal;
        TPtrC ignoredIfStartedFromVal;
        TPtrC resetIfThruVal;
        object->GetAttribute( KUidAttribute, uidVal );
        object->GetAttribute( KResetAttribute, resetVal );
        object->GetAttribute( KIgnoredAttribute, ignoredVal );
        object->GetAttribute( KIgnoredIfStartedFromAttribute,
            ignoredIfStartedFromVal );
        object->GetAttribute( KResetIfThruAttribute, resetIfThruVal );

        TInt uid = Str2Int( uidVal );

        if ( resetVal.Compare( KTrueValue ) == 0 )
            iResetApps.AppendL( uid );

        if ( ignoredVal.Compare( KTrueValue ) == 0 )
            iIgnoredApps.AppendL( uid );

        if ( ignoredIfStartedFromVal.Compare( KTrueValue ) == 0 )
            iIgnoredIfStartedFrom.AppendL( uid );

        if ( resetIfThruVal.Compare( KTrueValue ) == 0 )
            iResetIfThru.AppendL( uid );
        }

#ifdef _DEBUG    

    for ( TInt i = 0; i< iResetApps.Count( ); i++ )
        DEBUG(("\tiResetApps[%d] = %X)", i, iResetApps[i]));

    for ( TInt i = 0; i< iIgnoredApps.Count( ); i++ )
        DEBUG(("\tiIgnoredApps[%d] = %X)", i, iIgnoredApps[i]));

    for ( TInt i = 0; i< iIgnoredIfStartedFrom.Count( ); i++ )
        DEBUG(("\tiIgnoredIfStartedFrom[%d] = %X)", i, iIgnoredIfStartedFrom[i]));

    for ( TInt i = 0; i< iResetIfThru.Count( ); i++ )
        DEBUG(("\tiResetIfThru[%d] = %X)", i, iResetIfThru[i]));

#endif

    // clean up
    CleanupStack::PopAndDestroy( &nodes );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//   
TInt CBSConfiguration::Str2Int( const TDesC& aStr )
    {
    // if a string starts from '0x' then convert aStr from hex to int.
    // else send aStr to the StrDec2Uint

    TInt position(aStr.Find( KHexStart ) );
    TInt ret(KErrArgument);
    if ( position == 0 )
        {
        // is hex
        TPtrC string(aStr.Mid( KHexStart().Length( ) ) );

        TLex lexer(string);
        TUint val;
        lexer.Val( val, EHex );
        ret = val;
        }
    else
        {
        TLex lexer(aStr);
        lexer.Val( ret );
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// From class MXCFWEngineObserver
// 
// -----------------------------------------------------------------------------
//
void CBSConfiguration::HandleEngineEventL( TXCFWEngineEvent aEvent )
    {
    // handle completion
    if ( aEvent == EEvtParsingComplete )
        {
        LoadConfigurationL( );
        }
    }

// -----------------------------------------------------------------------------
// From class MXCFWEngineObserver
// 
// -----------------------------------------------------------------------------
//
void CBSConfiguration::HandleEngineErrorL( TInt /*aErrorCode*/)
    {
    }