/*

* Copyright (c)  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:  Service Provider Settings API's engine.

*

*/

#include <centralrepository.h>

#include <e32property.h>

#include <featmgr.h>

#include <cenrepdatabaseutil.h>

#include "spsettingsengine.h"

#include "spentry.h"

#include "spproperty.h"

#include "spcrkeys.h"

#include "spdefinitions.h"

#include "spdefaultvalues.h"

#include "spsapilogger.h" // For logging

const TInt KSPPredefinedCount = 2;

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

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

// Constructor

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

//

CSPSettingsEngine::CSPSettingsEngine()

    {

    }

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

// Constructor

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

//

void CSPSettingsEngine::ConstructL()

    {

    XSPSLOGSTRING( "CSPSettingsEngine::ConstructL() - IN" );

    iCenRepUtils = CCenRepDatabaseUtil::NewL( KCRUidSPSettings, 

                                            KSPStartKey,

                                            KSPColIncrement,         

                                            KSPColMask, 

                                            KServiceIdCounter,

                                            KSPColCount );

    XSPSLOGSTRING( "CSPSettingsEngine::ConstructL() - OUT" );

    }

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

// Constructor

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

//

CSPSettingsEngine* CSPSettingsEngine::NewL()

    {

    CSPSettingsEngine* self = CSPSettingsEngine::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

//

CSPSettingsEngine* CSPSettingsEngine::NewLC()

    {

    CSPSettingsEngine* self = new( ELeave ) CSPSettingsEngine;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CSPSettingsEngine::~CSPSettingsEngine()

    {

    XSPSLOGSTRING( "CSPSettingsEngine::~CSPSettingsEngine() - IN" );

    delete iCenRepUtils;

    XSPSLOGSTRING( "CSPSettingsEngine::~CSPSettingsEngine() - OUT" );

    }

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

// Begins transaction in repository.

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

//

TInt CSPSettingsEngine::BeginTransactionLC()

    {

    XSPSLOGSTRING( "CSPSettingsEngine::BeginTransaction() - IN" );

    iCenRepUtils->BeginTransactionL();

    XSPSLOGSTRING( "CSPSettingsEngine::BeginTransaction() - OUT" );

    return KErrNone;

    }

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

// Commits changes in repository.

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

//

TInt CSPSettingsEngine::CommitTransaction()

    {

    XSPSLOGSTRING( 

        "CSPSettingsEngine::CommitTransaction() - IN" );

    iCenRepUtils->CommitTransaction();

    XSPSLOGSTRING( "CSPSettingsEngine::CommitTransaction() - OUT" );

    return KErrNone;

    }

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

// Rollback changes in repository.

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

//

void CSPSettingsEngine::RollbackTransaction()

    {

    XSPSLOGSTRING( 

        "CSPSettingsEngine::RollbackTransaction() - IN" );

    iCenRepUtils->RollbackTransaction();

    XSPSLOGSTRING( "CSPSettingsEngine::RollbackTransaction() - OUT" );

    }

void CSPSettingsEngine::ConvertSpEntryToCenRepArrayL( const CSPEntry& aEntry, 

                                                     RIpAppPropArray& aArray )

    {

    CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();

    property->SetName( EServiceName );

    property->SetValue( aEntry.GetServiceName() );

    User::LeaveIfError( aArray.Append( property ) );

    CleanupStack::Pop( property );

    TInt count = aEntry.PropertyCount();

    const RPropertyArray& entryArray = aEntry.GetAllProperties();

    ConvertSpArrayToCenRepArrayL( entryArray, aArray );

    }

void CSPSettingsEngine::ConvertSpArrayToCenRepArrayL( const RPropertyArray& aSpArray,

                                                      RIpAppPropArray& aCenRepArray )

    {

    TInt count = aSpArray.Count();

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

        {

        CSPProperty* spProperty = aSpArray[i];

        CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();

        property->SetName( spProperty->GetName() );

        RBuf value;

        value.CreateL( KSPMaxDesLength );

        CleanupClosePushL( value);

        User::LeaveIfError( spProperty->GetValue( value ) );

        User::LeaveIfError( property->SetValue( value ) );

        CleanupStack::PopAndDestroy( &value );

        User::LeaveIfError( aCenRepArray.Append( property ) );

        CleanupStack::Pop( property );

        }

    }

void CSPSettingsEngine::CleanupPointerArray(  TAny* aPointer )

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

// Stores new service provider settings entry

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

//

void CSPSettingsEngine::AddEntryL( CSPEntry& aEntry )

    {

    XSPSLOGSTRING( "CSPSettingsEngine::AddEntryL() - IN" );

    // check the service name is not empty

    if( aEntry.GetServiceName().Length() == 0 )

    // construct RIpAppPropArray

    RIpAppPropArray array;

    ConvertSpEntryToCenRepArrayL( aEntry, array );

    // Create new unique service ID

    TInt newId = 0;

    iCenRepUtils->AddEntryL( newId, array );

    aEntry.SetServiceId( newId );

    CleanupStack::PopAndDestroy( &array );

    XSPSLOGSTRING( "CSPSettingsEngine::AddEntryL() - OUT" );

    }

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

// Find service provider settings entry by service ID

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

//

 TInt CSPSettingsEngine::FindEntryL( TServiceId aServiceId, CSPEntry& aEntry )

    {

    XSPSLOGSTRING2( "CSPSettingsEngine::FindEntryL( %d ) - IN", aServiceId );

    RIpAppPropArray array;

    TInt err = iCenRepUtils->FindEntryL( aServiceId, array );

    if( err == KErrNone )

        {

        TInt count = array.Count();

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

            {

            CCenRepDatabaseProperty* property = array[i];

            if( property->GetName() == EServiceName )

                {

                User::LeaveIfError( aEntry.SetServiceName( property->GetDesValue() ) );

                }

            else

                {

                CSPProperty* spProperty = CSPProperty::NewLC();

                User::LeaveIfError( spProperty->SetName( (TServicePropertyName)( property->GetName() )));

                User::LeaveIfError( spProperty->SetValue( property->GetDesValue() ));

                User::LeaveIfError( aEntry.AddPropertyL( *spProperty ));

                CleanupStack::PopAndDestroy( spProperty );

                }

            }

        }

    CleanupStack::PopAndDestroy( &array );

    aEntry.SetServiceId( aServiceId );

    XSPSLOGSTRING2( "CSPSettingsEngine::FindEntryL( %d ) - OUT", aServiceId );

    return err;

    }

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

// Update existing service provider settings entry

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

//

TInt CSPSettingsEngine::UpdateEntryL( const CSPEntry& aEntry )

    {

    XSPSLOGSTRING( "CSPSettingsEngine::UpdateEntry() - IN" );

    TServiceId serviceId( aEntry.GetServiceId() );

    // Leave if there is no service ID 

    if ( KSPNoId == serviceId || aEntry.GetServiceName().Length() == 0 )

        {

        User::Leave( KErrArgument );

        }

    // construct RIpAppPropArray

    RIpAppPropArray array;

    ConvertSpEntryToCenRepArrayL( aEntry, array );

    TInt err = iCenRepUtils->UpdateEntryL( (TInt) serviceId, array );

    CleanupStack::PopAndDestroy( &array );

    XSPSLOGSTRING( "CSPSettingsEngine::UpdateEntry() - OUT" );

    return err;

    }

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

// Deletes service provider settings entry by service ID

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

//

TInt CSPSettingsEngine::DeleteEntryL( TServiceId aServiceId )

    {

    XSPSLOGSTRING2( "CSPSettingsEngine::DeleteEntryL(%d) - IN", aServiceId );

    TInt err = iCenRepUtils->DeleteEntryL( aServiceId );

    XSPSLOGSTRING2( "CSPSettingsEngine::DeleteEntryL(%d) - OUT", aServiceId );

    return err;

    }

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

// Search property of service provider settings entry by property name

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

//

TInt CSPSettingsEngine::FindPropertyL( TServiceId aServiceId, 

    {

    XSPSLOGSTRING2( "CSPSettingsEngine::FindPropertyL(%d) - IN", aServiceId );

    CCenRepDatabaseProperty* cenrepProperty = CCenRepDatabaseProperty::NewLC();

    TInt err = iCenRepUtils->FindPropertyL( aServiceId, aPropertyName, *cenrepProperty );

    if( err == KErrNone )

        {

        User::LeaveIfError( aProperty.SetName( aPropertyName ) );

        User::LeaveIfError( aProperty.SetValue( cenrepProperty->GetDesValue()));

        }

    CleanupStack::PopAndDestroy( cenrepProperty );

    XSPSLOGSTRING2( "CSPSettingsEngine::FindPropertyL(%d) - OUT", aServiceId );

    return err;

    }

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

// Add or update properties of service provider settings entry

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

//

TInt CSPSettingsEngine::AddOrUpdatePropertiesL( TServiceId aServiceId,

    {

    XSPSLOGSTRING2( "CSPSettingsEngine::AddOrUpdatePropertiesL(%d) - IN", aServiceId );

    // construct RIpAppPropArray

    RIpAppPropArray array;

    ConvertSpArrayToCenRepArrayL( aPropertyArray, array );

    TInt err = iCenRepUtils->AddOrUpdatePropertiesL( aServiceId, array );    

    CleanupStack::PopAndDestroy( &array );

    XSPSLOGSTRING2( 

        "CSPSettingsEngine::AddOrUpdatePropertiesL(%d) - OUT", aServiceId );

    return err;

    }

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

// Returns count of stored service provider settings entries

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

//

TInt CSPSettingsEngine::SettingsCountL()

    {

    XSPSLOGSTRING( "CSPSettingsEngine::SettingsCount() - IN" );

    TInt result( 0 );

    TInt err = iCenRepUtils->EntryCountL( result );

    if( err == KErrNone )

        {

        if( result >= KSPPredefinedCount )

            {

            result--;

            }

        err = result;

        }

    else

        {

        err = 0;

        }

    XSPSLOGSTRING2( "CSPSettingsEngine::SettingsCount(%d) - OUT", result );

    return err;

    }

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

// Search stored service IDs of service provider settings entries

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

//

TInt CSPSettingsEngine::FindServiceIdsL( RIdArray& aServiceIds )

    {

    XSPSLOGSTRING( "CSPSettingsEngine::FindServiceIdsL() - IN" );

    RArray<TInt> cenrepArray;

    CleanupClosePushL( cenrepArray );

    TInt err = iCenRepUtils->FindEntryIdsL( cenrepArray );

    for( TInt i = 0; i < cenrepArray.Count(); i++ )

        {

        TServiceId id = (TServiceId)cenrepArray[i];

        if( id != KSPDefaultVoIPServiceId )

            {

            User::LeaveIfError( aServiceIds.Append( id ));

            }

        }

    CleanupStack::PopAndDestroy( &cenrepArray );

    XSPSLOGSTRING( "CSPSettingsEngine::FindServiceIdsL() - OUT" );

    return err;

    }

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

// Search service names by given service IDs

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

//

void CSPSettingsEngine::FindServiceNamesL( RIdArray& aServiceIds,

    CDesCArray& aServiceNames )

    {

    XSPSLOGSTRING( "CSPSettingsEngine::FindServiceNamesL() - IN" );

    CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();

    TInt count = aServiceIds.Count();

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

        {

        TInt id = ( TInt )aServiceIds[i];

        TInt err = iCenRepUtils->FindPropertyL( id, EServiceName, *property );

        if( err == KErrNone )

            {

            aServiceNames.AppendL( property->GetDesValue() );

            }

        else

            {

            aServiceIds.Remove( i ); // Remove non-existent ID

            count--;

            i--; // Do not increment index

            }

        }

    CleanupStack::PopAndDestroy( property );

    XSPSLOGSTRING( "CSPSettingsEngine::FindServiceNamesL() - OUT" );

    }

void CSPSettingsEngine::PropertyNameArrayFromItemTypeL( TSPItemType aPropertyType, 

                                                        RPropertyNameArray& aNameArray )

    {

    switch ( aPropertyType )

        {

        case EItemTypeVoIPSubProperty:

            {

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPSettingsId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPPreferredSNAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPPreferredIAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPTemporaryIAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPRelNumber ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPBrandDataUri ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPBrandIconUri ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPAddrScheme ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVoIPEnabled ) );

            break;

            }

        case EItemTypePresenceSubProperty:

            {

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceSettingsId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresencePreferredSNAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresencePreferredIAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresencePresentityIDFieldType ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceLaunchMethod ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceLaunchUid ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceAddrScheme ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceEnabled ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyPresenceRequestPreference ) );

            break;

            }

        case EItemTypeIMSubProperty:

            {

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMSettingsId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMPreferredSNAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMPreferredIAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMLaunchMethod ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMLaunchUid ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMAddrScheme ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyIMEnabled ) );

            break;

            }

        case EItemTypeVMBXSubProperty:

            {

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXSettingsId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXPreferredSNAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXPreferredIAPId ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXMWISubscribeInterval ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXLaunchMethod ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXLaunchUid ) );

            User::LeaveIfError( aNameArray.Append( ESubPropertyVMBXListenAddress ) );