/*

* Copyright (c) 2002-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:  Stores and loads CRCSEProfileEntry to/from data storage.

*

*/

// INCLUDE FILES

#include <sipmanagedprofileregistry.h>

#include <sipprofile.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spdefinitions.h>

#include <featmgr.h>

#include <cenrepdatabaseutil.h>

#include <cenrepdatabaseproperty.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "crcseprofileregistry.h"

#include "crcseprofileentry.h"

#include "crcseaudiocodecregistry.h"

#include "rcsepanic.h"

#include "rcseconstants.h"

#include "rcsedefaults.h"

#include "rcseprivatecrkeys.h"

#include "rcselogger.h"

const TInt KArrayInitSize = 2;

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

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

// CRCSEProfileRegistry::CRCSEProfileRegistry

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

// might leave.

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

//

CRCSEProfileRegistry::CRCSEProfileRegistry()

    : CRCSERegistryBase( EVoIPProfile ),

      iSIPRegistry( NULL )

    {

    }

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

// CRCSEProfileRegistry::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRCSEProfileRegistry::ConstructL()

    {

    // Check VoIP support from feature manager

    FeatureManager::InitializeLibL();

    TBool support = FeatureManager::FeatureSupported( KFeatureIdCommonVoip );

    FeatureManager::UnInitializeLib();

    if ( !support )

        {

        User::Leave( KErrNotSupported );

        }

    BaseConstructL();

    iSIPRegistry = CSIPManagedProfileRegistry::NewL( *this );

    }

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

// CRCSEProfileRegistry::NewL

// Two-phased constructor.

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

//

EXPORT_C CRCSEProfileRegistry* CRCSEProfileRegistry::NewL()

    {

    CRCSEProfileRegistry* self = CRCSEProfileRegistry::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CRCSEProfileRegistry::NewLC

// Two-phased constructor.

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

//

EXPORT_C CRCSEProfileRegistry* CRCSEProfileRegistry::NewLC()

    {

    CRCSEProfileRegistry* self = new( ELeave ) CRCSEProfileRegistry;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

EXPORT_C CRCSEProfileRegistry::~CRCSEProfileRegistry()

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::~CRCSEProfileRegistry() - IN" );

    delete iSIPRegistry;

    iSIPProfiles.ResetAndDestroy();

    RCSELOGSTRING( "CRCSEProfileRegistry::~CRCSEProfileRegistry() - OUT" );

    }

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

// CRCSEProfileRegistry::FindL

// Start search of profile entry by provider name.

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

//

EXPORT_C void CRCSEProfileRegistry::FindL( 

    const TDesC& aProviderName,

    CRCSEProfileEntry& aFoundEntry )

    {

    RCSELOGSTRING2( "CRCSEProfileRegistry::FindL(%S) - IN", &aProviderName );

    BeginL();

    RArray<TUint32> entryIds;

    CleanupClosePushL( entryIds );

    // Search IDs of entries that have this service ID

    FindIdsByValueL( KColProviderName,

                     aProviderName, 

                     entryIds );

    // Search whole entry if ID was found

    if ( 0 < entryIds.Count() )

        {

        FindEntryL( entryIds[ 0 ], aFoundEntry );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    // Check that SIP Ids are valid

    UpdateSIPProfileLinksL( aFoundEntry );

    CleanupStack::PopAndDestroy( &entryIds );

    EndL();

    RCSELOGSTRING2( "CRCSEProfileRegistry::FindL(%S) - OUT", &aProviderName );

    }

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

// CRCSEProfileRegistry::FindL

// Start search of profile entry by ID.

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

//

EXPORT_C void CRCSEProfileRegistry::FindL( 

    TUint32 aProfileId, 

    CRCSEProfileEntry& aFoundEntry )

    {

    RCSELOGSTRING2( "CRCSEProfileRegistry::FindL(id=%d) - IN", aProfileId );

    BeginL();

    FindEntryL( aProfileId, aFoundEntry );

    // Check that SIP Ids are valid

    UpdateSIPProfileLinksL( aFoundEntry );

    EndL();

    RCSELOGSTRING2( "CRCSEProfileRegistry::FindL(id=%d) - OUT", aProfileId );

    }

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

// CRCSEProfileRegistry::AddL

// Start addition of profile entry.

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

//

EXPORT_C TUint32 CRCSEProfileRegistry::AddL( 

    const CRCSEProfileEntry& aNewEntry )

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::AddL() - IN" );

    BeginL();

    TUint32 id( KNoEntryId );

    // Add entry to storage

    AddOrUpdateEntryL( id, aNewEntry );

    __ASSERT_ALWAYS( KNoEntryId < id, User::Leave( KErrCorrupt ) );

    // Create service settings or use existing

    CRCSEProfileEntry& modifyEntry 

        = const_cast<CRCSEProfileEntry&>( aNewEntry );

    // New service settings entry...

    if( ( CRCSEProfileEntry::EOONotSet == modifyEntry.iNewServiceTableEntry ||

          CRCSEProfileEntry::EOn == modifyEntry.iNewServiceTableEntry ) )

        {

        CreateDefaultServiceSettingsL( modifyEntry );

        if ( modifyEntry.iServiceProviderId != KRCSEDefServiceProviderId )

            {

            UpdateServiceIdL( id, modifyEntry.iServiceProviderId );

            }

        }

    // Use existing service settings entry if

    // - given service id is valid

    // - service id is not used by another profile

    // - provider name is valid

    else if( CRCSEProfileEntry::EOff == modifyEntry.iNewServiceTableEntry &&

             KSPNoId < modifyEntry.iServiceProviderId )

        {

        // Check that provide name is valid

        TBool providerExist( 

            NameExistsInServiceTableL( modifyEntry.iProviderName ) );

        if( !providerExist )

            {

            User::Leave( KErrNotFound );

            }

        // Check that service id is not used by another profile

        LeaveIfServiceIdInUseL( modifyEntry );

        }

    // Fail all other cases

    else

        {

        User::Leave( KErrArgument );

        }

    EndL();

    RCSELOGSTRING( "CRCSEProfileRegistry::AddL() - OUT" );

    return id;

    }

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

// CRCSEProfileRegistry::DeleteL

// Deletes a profile entry which profile id is aProfileId.

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

//

EXPORT_C void CRCSEProfileRegistry::DeleteL( 

    TUint32 aProfileId )

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::DeleteL() - IN" );

    // Delete referenced settings first

    DeleteReferenceSettingsL( aProfileId );

    // Start transaction here since referenced settings are

    // deleted in own separate transaction

    BeginL();

    // Delete actual profile

    iCenRepDb->DeleteEntryL( aProfileId );

    EndL();

    RCSELOGSTRING( "CRCSEProfileRegistry::DeleteL() - OUT" );

    }

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

// CRCSEProfileRegistry::UpdateL

// Updates profile entry, which profile identifier is aId.

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

//

EXPORT_C void CRCSEProfileRegistry::UpdateL(

    TUint32 aId, const CRCSEProfileEntry& aUpdateData )

    {

    RCSELOGSTRING2( "CRCSEProfileRegistry::UpdateL(%d) - IN", aId );

    __ASSERT_ALWAYS( KNoEntryId < aId, User::Leave( KErrArgument ) );

    BeginL();

    AddOrUpdateEntryL( aId, aUpdateData );

    // Update also service settings if needed

    if ( aUpdateData.iIds.Count() && 

        aUpdateData.iIds[0].iProfileType == CRCSEProfileEntry::EProtocolSIP )

        {

        if ( aUpdateData.iServiceProviderId == KRCSEDefServiceProviderId )

            {

            CRCSEProfileEntry* entry = CRCSEProfileEntry::NewLC();

            CopyEntryValues( aUpdateData, *entry );

            CreateDefaultServiceSettingsL( *entry );

            UpdateServiceSettingsL( *entry );

            AddOrUpdateEntryL( aId, *entry );

            CleanupStack::PopAndDestroy( entry );

            }

        else

            {

            UpdateServiceSettingsL( aUpdateData );

            }

        }

    EndL();

    RCSELOGSTRING2( "CRCSEProfileRegistry::UpdateL(%d) - OUT", aId );

    }

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

// CRCSEProfileRegistry::GetDefaultProfile

// Resets a default profile values.

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

//

EXPORT_C void CRCSEProfileRegistry::GetDefaultProfile( 

    CRCSEProfileEntry& aDefaultProfile ) const

    {

    aDefaultProfile.ResetDefaultValues();

    }

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

// CRCSEProfileRegistry::GetAllIdsL

// Gets all profile identifiers.

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

//

EXPORT_C void CRCSEProfileRegistry::GetAllIdsL( RArray<TUint32>& aAllIds )

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::GetAllIdsL() - IN" );

    BeginL();

    FindAllIdsL( aAllIds );

    EndL();

    RCSELOGSTRING( "CRCSEProfileRegistry::GetAllIdsL() - OUT" );

    }

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

// CRCSEProfileRegistry::FindByServiceIdL

// Gets all profiles matching to service ID.

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

//

EXPORT_C void CRCSEProfileRegistry::FindByServiceIdL( TUint32 aServiceId, 

    RPointerArray<CRCSEProfileEntry>& aFoundEntries )

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::FindByServiceIdL() - IN" );

    CleanupResetAndDestroyPushL( aFoundEntries );

    BeginL();

    TBuf<KDesLength128> des;

    RArray<TUint32> entryIds;

    CleanupClosePushL( entryIds );

    // Search IDs of entries that have this service ID

    FindIdsByValueL( KColServiceProviderId,

                     ToDes( aServiceId, des ), 

                     entryIds );

    const TInt count( entryIds.Count() );

    RCSELOGSTRING2( " - Entries found: %d", count );

    // Search entries using found IDs

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

        {

        CRCSEProfileEntry* entry = CRCSEProfileEntry::NewLC();

        TRAPD( e, FindEntryL( entryIds[ i ], *entry ) );

        if ( KErrNone == e )

            {

            aFoundEntries.AppendL( entry );

            CleanupStack::Pop( entry );

            }

        else

            {

            CleanupStack::PopAndDestroy( entry );

            }

        }

    CleanupStack::PopAndDestroy( &entryIds );

    // Update SIP profile links

    const TInt entryCount( aFoundEntries.Count() );

    for ( TInt k( 0 ); k < entryCount; ++k )

        {

        UpdateSIPProfileLinksL( *aFoundEntries[k] );

        }

    EndL();

    CleanupStack::Pop( &aFoundEntries );

    RCSELOGSTRING( "CRCSEProfileRegistry::FindByServiceIdL() - OUT" );

    }

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

// CRCSEProfileRegistry::FindBySIPSprofileIdL

// Gets all profiles based on SIP profile ID.

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

//

EXPORT_C void CRCSEProfileRegistry::FindBySIPProfileIdL( TUint32 aSipProfileId, 

    RPointerArray<CRCSEProfileEntry>& aFoundEntries )

    {

    RCSELOGSTRING( "CRCSEProfileRegistry::FindBySIPProfileIdL() - IN" );

    CleanupResetAndDestroyPushL( aFoundEntries );

    BeginL();

    // Find all profile IDs

    RArray<TUint32> voipIds;

    CleanupClosePushL( voipIds );

    FindAllIdsL( voipIds );

    // Check protocol ids (iIds) from each found profile ID.

    // Leave only those profile IDs where match found.

    CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();

    TInt count( voipIds.Count() );

    RArray<TSettingIds> prIds;

    CleanupClosePushL( prIds );

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

        {

        iCenRepDb->FindPropertyL( voipIds[ i ], KColProtocolIds, *property );

        const TDesC& value = property->GetDesValue();

        ExtractProtocoIdsL( value, prIds );

        TBool found( EFalse );

        TInt prIdCount( prIds.Count() );

        for ( TInt j( 0 ); j < prIdCount && !found; j++ )

            {

            if ( prIds[ j ].iProfileType == CRCSEProfileEntry::EProtocolSIP && 

                 prIds[ j ].iProfileId == aSipProfileId )

                {

                found = ETrue;

                }

            }

        // Search profile if match found

        if ( found )

            {

            CRCSEProfileEntry* entry = CRCSEProfileEntry::NewLC();

            TRAPD( e, FindEntryL( voipIds[ i ], *entry ) );

            if ( KErrNone == e )

                {

                aFoundEntries.AppendL( entry );

                CleanupStack::Pop( entry );

                }

            else

                {

                CleanupStack::PopAndDestroy( entry );

                }

            }

        }

    CleanupStack::PopAndDestroy( &prIds );

    CleanupStack::PopAndDestroy( property );

    // Update SIP profile links

    TInt entryCount( aFoundEntries.Count() );

    for ( TInt k( 0 ); k < entryCount; ++k )

        {

        UpdateSIPProfileLinksL( *aFoundEntries[k] );

        }

    CleanupStack::PopAndDestroy( &voipIds );

    EndL();

    CleanupStack::Pop( &aFoundEntries );

    RCSELOGSTRING( "CRCSEProfileRegistry::FindBySIPProfileIdL() - OUT" );

    }

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

// CRCSEProfileRegistry::AddL

// Add bunch of entries to store

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

//

void CRCSEProfileRegistry::AddL( 

    RPointerArray<CRCSEProfileEntry>& aEntries )

    {

    RCSELOGSTRING2( 

        "CRCSEProfileRegistry::AddL( %d entries) - IN", aEntries.Count() );

    BeginL();

    TInt count( aEntries.Count() );

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

        {

        // Create service settings if service ID is not available for entry

        if (  KRCSEDefServiceProviderId == aEntries[ i ]->iServiceProviderId )

            {

            CreateDefaultServiceSettingsL( *aEntries[ i ] );

            }

        TUint32 id( KNoEntryId );

        AddOrUpdateEntryL( id, *aEntries[ i ] );

        aEntries[ i ]->iId = id;

        }

    EndL();

    RCSELOGSTRING( "CRCSEProfileRegistry::AddL(entries) - OUT" );

    }

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

// CRCSEProfileRegistry::FindEntryL

// Do actual search of profile entry

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

//