/*
* Copyright (c) 2002 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:  MuiuFlagger implementation
*
*/




// INCLUDE FILES
#include <e32base.h>        
#include <featmgr.h>            // Feature Manager
#include <centralrepository.h>  // CRepository
#include "MuiuFlagger.h"        // CMuiuFlags


// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES  
// CONSTANTS
const TInt KMuiuFlaggerMaxFlags = 64;
_LIT( KMuiuFlaggerPanic, "MuiuFlagger" );

// MACROS
// LOCAL CONSTANTS AND MACROS
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
// FORWARD DECLARATIONS

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


// ------------------------------ CONSTRUCTORS --------------------------------


// ----------------------------------------------------------------------------
// CMuiuFlags::CMuiuFlags()
// ----------------------------------------------------------------------------
//
CMuiuFlags::CMuiuFlags()
    {    
    }

// ----------------------------------------------------------------------------
// CMuiuFlags::~CMuiuFlags()
// ----------------------------------------------------------------------------
//
EXPORT_C CMuiuFlags::~CMuiuFlags()
    {
    }

// ----------------------------------------------------------------------------
// CMuiuFlags::NewL()
// ----------------------------------------------------------------------------
//
EXPORT_C CMuiuFlags* CMuiuFlags::NewL(
    const TMuiuGlobalFeatureArray* aGlobalFeatures,
    const TMuiuLocalFeatureArray* aLocalFeatures,
    const TMuiuFlagArray* aFlags )
    {
    CMuiuFlags* self = NewLC( aGlobalFeatures, aLocalFeatures, aFlags );
    CleanupStack::Pop( self );
    
    return self;
    }
    
// ----------------------------------------------------------------------------
// CMuiuFlags::NewLC()
// ----------------------------------------------------------------------------
//
EXPORT_C CMuiuFlags* CMuiuFlags::NewLC(
    const TMuiuGlobalFeatureArray* aGlobalFeatures,
    const TMuiuLocalFeatureArray* aLocalFeatures,
    const TMuiuFlagArray* aFlags )
    { 
    CMuiuFlags* self = new ( ELeave ) CMuiuFlags();  
    
    CleanupStack::PushL( self );
    self->ConstructL( aGlobalFeatures, aLocalFeatures, aFlags );
    
    return self;
    }    

        
// ----------------------------------------------------------------------------
// CMuiuFlags::ConstructL()
// ----------------------------------------------------------------------------
//
void CMuiuFlags::ConstructL(
    const TMuiuGlobalFeatureArray* aGlobalFeatures,
    const TMuiuLocalFeatureArray* aLocalFeatures,
    const TMuiuFlagArray* aFlags )
    {
    if ( aGlobalFeatures )
        {
        PrepareGlobalFeaturesL( *aGlobalFeatures );
        }
    
    // Local features
    if ( aLocalFeatures )
        {
        PrepareLocalFeaturesL( *aLocalFeatures );
        }

    // Normal flags
    if ( aFlags )
        {
        PrepareGeneralFlags( *aFlags );
        }
    }
    
    
// ----------------------------- FLAG HANDLERS --------------------------------
    
        
// ----------------------------------------------------------------------------
// CMuiuFlags::PrepareGlobalFeaturesL()
// ----------------------------------------------------------------------------
//    
void CMuiuFlags::PrepareGlobalFeaturesL( 
    const TMuiuGlobalFeatureArray& aGlobalFeatures )
    {
    TUint64 feature = aGlobalFeatures.Count();
    
    // Compare the number of given features against the maximum number
    // of featureflags possible. Panic if the number of flags has been 
    // exceeded.
    __ASSERT_ALWAYS( 
        feature <= KMuiuFlaggerMaxFlags, 
        User::Panic( KMuiuFlaggerPanic, KErrOverflow ) );
    
    FeatureManager::InitializeLibL();
    
    // Check all the features in array from feature manager and set
    // the flags in the same order as in the array
    while ( feature-- > 0 )
        {
        ChangeGF( feature, 
            FeatureManager::FeatureSupported( 
                aGlobalFeatures[feature] ) );      
        }
              
    FeatureManager::UnInitializeLib();
    }

// ----------------------------------------------------------------------------
// CMuiuFlags::PrepareLocalFeaturesL()
// ----------------------------------------------------------------------------
//
void CMuiuFlags::PrepareLocalFeaturesL(
    const TMuiuLocalFeatureArray& aLocalFeatures )
    {
    TUint64 feature = aLocalFeatures.Count();
    
    // Compare the number of given features against the maximum number
    // of featureflags possible. Panic if the number of flags has been 
    // exceeded.
    __ASSERT_ALWAYS( 
        feature <= KMuiuFlaggerMaxFlags, 
        User::Panic( KMuiuFlaggerPanic, KErrOverflow ) );              
    
    TInt value = 0;
    
    // Get Next CenRep session
    while ( feature-- > 0 )
        {
        // Create temporary structure for the feature
        TMuiuLocalFeatureItem localFeature = aLocalFeatures[feature];
        
        // Create the connection
        CRepository* cenrep = 
            CRepository::NewLC( localFeature.iUid );
            
        // Get the value from repository
        User::LeaveIfError( 
            cenrep->Get( localFeature.iKeyId, value ) );
                    
        // Define the feature flag
        if ( !localFeature.iIsFlag )
            {
            // The value in iFlag is actually an index, so roll on to right
            // and mask the other flags
            ChangeLF( feature, ( value >> localFeature.iFlag ) & 0x01 );
            }
        else
            {
            // The value in iFlag is a real flag, so do the normal 
            // and -operation and check if the bit is on
            ChangeLF( feature, ( value & localFeature.iFlag ) > 0 );
            }            
                            
        // Destroy the object
        CleanupStack::PopAndDestroy( cenrep );
        cenrep = NULL;
        }         
    }
    

// ----------------------------------------------------------------------------
// CMuiuFlags::PrepareGeneralFlags()
// ----------------------------------------------------------------------------
//
void CMuiuFlags::PrepareGeneralFlags(
    const TMuiuFlagArray& aFlags )
    {
    TUint64 feature = aFlags.Count();
    
    // Compare the number of given features against the maximum number
    // of featureflags possible. Panic if the number of flags has been 
    // exceeded.
    __ASSERT_ALWAYS( 
        feature <= KMuiuFlaggerMaxFlags, 
        User::Panic( KMuiuFlaggerPanic, KErrOverflow ) );  
        
    // Check all the flags in array and set the flags in the 
    // same order as in the array
    while ( feature-- > 0 )
        {
        ChangeFlag( feature, 
            FeatureManager::FeatureSupported( 
                aFlags[feature] ) );
        }
    }    
    
    
// End of File