/*
* Copyright (c) 2004-2010 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:  Base for RCSE registry classes
*
*/


//#include <cenrepdatabaseutil.h>
//#include <cenrepdatabaseproperty.h>


#include "rcseregistrybase.h"
#include "rcsebackupobserver.h"
#include "rcsedefaultdbnames.h"
#include "rcseconstants.h"
#include "rcsepanic.h"
#include "rcseprivatecrkeys.h"
#include "rcselogger.h"
#include "rcsedbimporter.h"


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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CRCSERegistryBase::CRCSERegistryBase( TRCSERegistryType aType )
    : iType( aType )
    {
    }

// ---------------------------------------------------------------------------
// BaseConstructL
// ---------------------------------------------------------------------------
//
void CRCSERegistryBase::BaseConstructL()
    {
    RCSELOGSTRING2( "CRCSERegistryBase::BaseConstructL(type=%d) - IN", iType );
    RCSELOGTHREAD();

    // Set proper table and mask
    switch ( iType )
        {
        case EVoIPProfile:
            {
            iCenRepDb = CCenRepDatabaseUtil::NewL( KCRUidRCSE,
                                                   KRCSEProfileTable,
                                                   KRCSEColIncrement,
                                                   KRCSEColumnMask,
                                                   KRCSEIdCounter,
                                                   KRCSEColumnCountVoIP );
            break;
            }
        case EAudioCodecSetting:
            {
            iCenRepDb = CCenRepDatabaseUtil::NewL( KCRUidRCSECodec,
                                                   KRCSECodecTable,
                                                   KRCSEColIncrement,
                                                   KRCSEColumnMask,
                                                   KRCSEIdCounter,
                                                   KRCSEColumnCountCodec );

            break;
            }
        default:
            {
            User::Leave( KErrNotSupported );
            }
        };

    iBackupObserver = CRCSEBackupObserver::NewL( *this );

    TInt err( 0 );

    // Check if Backup operation is running.
    if ( iBackupObserver->IsBackupOperationRunning() )
        {
        RCSELOGSTRING( "Backup active!" );
        iBackupActive = ETrue;
        }

    if ( !iBackupActive &&
         CRCSEDbImporter::ImportExists() &&
         !CRCSEDbImporter::IsImportRunning() )
        {
        TRAP( err, ImportSettingsL() );
        }

    RCSELOGSTRING( "CRCSERegistryBase::BaseConstructL() - OUT" );
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CRCSERegistryBase::~CRCSERegistryBase()
    {
    RCSELOGSTRING2( 
        "CRCSERegistryBase::~CRCSERegistryBase(type=%d) - IN", iType );
    RCSELOGTHREAD();

    if ( iBackupObserver )
        {
        iBackupObserver->Cancel();
        delete iBackupObserver;
        iBackupObserver = NULL;
        }


    delete iCenRepDb;

    RCSELOGSTRING( "CRCSERegistryBase::~CRCSERegistryBase() - OUT" );
    }

// ---------------------------------------------------------------------------
// From class MRCSEBackupObserver.
// Handle backup events.
// ---------------------------------------------------------------------------
//
void CRCSERegistryBase::HandleBackupOperationEventL()
	{
	RCSELOGSTRING( "CRCSERegistryBase::HandleBackupOperationEventL() - IN" );
    RCSELOGTHREAD();

	if ( iBackupObserver->IsBackupOperationRunning() )
        {
        RCSELOGSTRING( "Backup active!" );
        iBackupActive = ETrue;
        }
    else
        {
        RCSELOGSTRING( "Backup not active!" );
        iBackupActive = EFalse;
		}

    RCSELOGSTRING( "CRCSERegistryBase::HandleBackupOperationEventL() - OUT" );
	}

// -----------------------------------------------------------------------------
// CRCSERegistryBase::BeginL
// Prepares read/write operation.
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::BeginL()
    {
    RCSELOGSTRING( "CRCSERegistryBase::BeginL() - IN" );
    RCSELOGTHREAD();

    if ( iBackupActive )
        {
        User::Leave( KErrNotReady );
        }

    else 
        {
        RCSELOGSTRING( "Begin transaction" );

        // Begin transaction. Method leaves 2 items in cleanup stack
        // and they will be removed in CommitTransaction
        iCenRepDb->BeginTransactionL(); 
        }

    RCSELOGSTRING( "CRCSERegistryBase::BeginL() - OUT" );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::EndL
// Finalize performed operation
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::EndL()
    {
    RCSELOGSTRING( "CRCSERegistryBase::EndL() - IN" );
    RCSELOGTHREAD();

    User::LeaveIfError( iCenRepDb->CommitTransaction() );

    RCSELOGSTRING( "CRCSERegistryBase::EndL() - OUT" );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::ToDes
// Converts TInt32 to descriptor.
// -----------------------------------------------------------------------------
//
TDesC& CRCSERegistryBase::ToDes( TInt32 aFrom, TDes& aTo )
    {
    aTo.Zero();
    aTo.AppendNum( aFrom );
    return aTo;
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::ToDes
// Converts TUint32 to descriptor.
// -----------------------------------------------------------------------------
//
TDesC& CRCSERegistryBase::ToDes( TUint32 aFrom, TDes& aTo )
    {
    aTo.Zero();
    aTo.AppendNum( aFrom );
    return aTo;
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::ToDes
// Converts descriptor to TInt32.
// -----------------------------------------------------------------------------
//
TInt32 CRCSERegistryBase::ToTInt32L( const TDesC& aFrom )
    {
    TInt32 value;
    TLex16 convert( aFrom );
    User::LeaveIfError( convert.Val( value ) );
    return value;
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::ToDes
// Converts descriptor to TUint32.
// -----------------------------------------------------------------------------
//
TUint32 CRCSERegistryBase::ToTUint32L( const TDesC& aFrom)
    {
    TUint32 value;
    TLex16 convert( aFrom );
    User::LeaveIfError( convert.Val( value, EDecimal ) );
    return value;
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::ImportSettingsL
// Import settings from db files and store to cenrep.
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::ImportSettingsL()
    {
    RCSELOGSTRING( "CRCSERegistryBase::ImportSettingsL() - IN" );
    RCSELOGTHREAD();

    CRCSEDbImporter* importer = CRCSEDbImporter::NewLC();
    importer->ImportAndStoreL();
    CleanupStack::PopAndDestroy( importer );

    RCSELOGSTRING( "CRCSERegistryBase::ImportSettingsL() - OUT" );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::CreatePropertyL
// Create a new property and appends it to given property array
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::CreatePropertyL( 
    TUint aPropertyName, 
    const TDesC& aPropertyValue, 
    RIpAppPropArray& aPropertyArray )
    {
    CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();
    property->SetName( aPropertyName );
    User::LeaveIfError( property->SetValue( aPropertyValue ) );
    aPropertyArray.AppendL( property );
    CleanupStack::Pop( property );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::GetPropertyValueL
// Gets value of requested property from array
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::GetPropertyValueL( 
    TUint aPropertyName, 
    TDes& aPropertyValue, 
    RIpAppPropArray& aPropertyArray )
    {
    aPropertyValue.Zero();

    const TInt count( aPropertyArray.Count() );
    for ( TInt i( 0 ); i < count; i++ )
        {
        if ( aPropertyArray[i]->GetName() == aPropertyName )
            {
            aPropertyValue = aPropertyArray[i]->GetDesValue();
            //delete aPropertyArray[i];
            //aPropertyArray.Remove( i );
            i = count; // Stop the loop
            }
        }
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::FindIdsByValueL
// Search entries that have this property and requested value.
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::FindIdsByValueL( 
    TUint aPropertyName, 
    const TDesC& aPropertyValue, 
    RArray<TUint32>& aIdArray )
    {    
    RArray<TInt> allEntries;
    CleanupClosePushL( allEntries );

    iCenRepDb->FindEntryIdsL( allEntries );
    
    CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();
    
    const TInt allCount( allEntries.Count() );
    
    for ( TInt i( 0 ); i < allCount; i++ )
        {        
        TInt err = iCenRepDb->FindPropertyL( allEntries[i], aPropertyName,
                *property );
        
        if ( KErrNoMemory == err )
            {
            User::Leave( err );
            }
        
        if ( KErrNone == err )
            {            
            // If properties match, add id to the id array.
            if ( !property->GetDesValue().Compare( aPropertyValue ) )
                {                
                aIdArray.AppendL( allEntries[i] );
                }
            }
        }
    
    CleanupStack::PopAndDestroy( property );
    CleanupStack::PopAndDestroy( &allEntries );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::FindAllIdsL
// Search all ids of entries from cenrep db.
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::FindAllIdsL( RArray<TUint32>& aIdArray )
    {
    CleanupClosePushL( aIdArray );
    aIdArray.Reset();

    RArray<TInt> ids;
    CleanupClosePushL( ids );

    iCenRepDb->FindEntryIdsL( ids );

    // TInt to TUint
    const TInt count( ids.Count() );
    for ( TInt i( 0 ); i < count; i++ )
        {
        aIdArray.AppendL( ids[ i ] );
        }

    CleanupStack::PopAndDestroy( &ids );
    CleanupStack::Pop( &aIdArray );
    }

// -----------------------------------------------------------------------------
// CRCSERegistryBase::CleanupDbPropArray
// Custom cleanup for cenrep db property array.
// -----------------------------------------------------------------------------
//
void CRCSERegistryBase::CleanupDbPropArray( TAny* aPointer )
	{
	RIpAppPropArray* array = static_cast<RIpAppPropArray*>( aPointer );
	array->ResetAndDestroy();
	}