/*

* Copyright (c) 2007-2009 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:  For CSC needed Service Provider Settings handling

*

*/

#include <spentry.h>

#include <spproperty.h>

#include <spsettings.h>

#include <spnotifychange.h>

#include <spsettingsvoiputils.h>

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include "cscenglogger.h"

#include "cscengservicehandler.h"

#include "mcscengserviceobserver.h"

const TInt KDummyServiceCount = 1;// only remove cs service, VoIP service is not returned

const TInt KArrayInitSize = 2;

// SCP-plugin uid for Sip VoIP

const TInt32 KSipVoIPSubServicePlugId = 0x1027545A;

// Preferred Telephony value is PS call

const TInt KRCSEInternetCallPreferred = 1;

// Preferred Telephony value is CS call

const TInt KRCSECSCallPreferred = 0;

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

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

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

//

CCSCEngServiceHandler::CCSCEngServiceHandler()

    {    

    }

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

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

//

void CCSCEngServiceHandler::ConstructL( MCSCEngServiceObserver* aObserver )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::ConstructL - begin" ); 

    iObserver = aObserver;

    iServiceSettings = CSPSettings::NewL();

    iNotifier = CSPNotifyChange::NewL( *this );

    iSettingsVoIPUtils = CSPSettingsVoIPUtils::NewL();

    RArray<TUint> serviceIds;

    iNotifier->NotifyChangeL( serviceIds );

    CSCENGDEBUG( "CCSCEngServiceHandler::ConstructL - end" ); 

    }   

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

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

//

EXPORT_C CCSCEngServiceHandler* CCSCEngServiceHandler::NewL( 

    MCSCEngServiceObserver* aObserver )

    {    

    CCSCEngServiceHandler* self = new (ELeave) CCSCEngServiceHandler;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CCSCEngServiceHandler::~CCSCEngServiceHandler()

    {

    CSCENGDEBUG( 

        "CCSCEngServiceHandler::~CCSCEngCenrepHandler - begin" ); 

    iServiceName.Close();

    delete iSettingsVoIPUtils;

    delete iServiceSettings;

    delete iNotifier;

    CSCENGDEBUG( 

        "CCSCEngServiceHandler::~CCSCEngCenrepHandler - end" ); 

    }

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

// For getting all service ids

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

//

EXPORT_C void CCSCEngServiceHandler::GetAllServiceIdsL( 

    RArray<TUint>& aServiceIds )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::GetAllServiceIds - begin" ); 

    iServiceSettings->FindServiceIdsL( aServiceIds );

    // Remove 'dummy service's' from service ids list.

    if ( KDummyServiceCount <= aServiceIds.Count() )

        {

        for ( TUint i = 0; i < KDummyServiceCount; i++ )

            {

            aServiceIds.Remove( 0 );

            }

        }

    CSCENGDEBUG( "CCSCEngServiceHandler::GetAllServiceIds - end" ); 

    }

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

// For getting service provider settings count

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

//

EXPORT_C TInt CCSCEngServiceHandler::ServiceIdCountL()

    {

    CSCENGDEBUG2( 

        "CCSCEngServiceHandler::ServiceIdCount COUNT=%d", 

            iServiceSettings->SettingsCountL() );

    return iServiceSettings->SettingsCountL();

    }

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

// For deleting service

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

//

EXPORT_C void CCSCEngServiceHandler::DeleteServiceL( TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::DeleteServiceL - begin" );

    User::LeaveIfError( iServiceSettings->DeleteEntryL( aServiceId ) );

    CSCENGDEBUG( "CCSCEngServiceHandler::DeleteServiceL - end" );

    }

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

// For getting service name

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

//

EXPORT_C const TDesC16& CCSCEngServiceHandler::ServiceNameL( 

    TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::ServiceNameL - begin" );

    iServiceName.Zero();

    RArray<TUint> serviceIds;

    CleanupClosePushL( serviceIds );

    GetAllServiceIdsL( serviceIds );

    CDesCArray* serviceNames = 

        new ( ELeave ) CDesCArrayFlat( KArrayInitSize );

    CleanupStack::PushL( serviceNames );

    iServiceSettings->FindServiceNamesL( serviceIds, *serviceNames );

    TBool serviceFound( EFalse );

    for ( TInt i( 0 ) ; i < serviceIds.Count() && !serviceFound ; i++ )

        {

        if ( aServiceId == serviceIds[ i ] )

            {

            serviceFound = ETrue;

            iServiceName.Close();

            iServiceName.CreateL( serviceNames->MdcaPoint( i ) );

            }

        }

    if ( !serviceFound )

        {

        User::Leave( KErrNotFound ); // leave if service not found

        }

    CleanupStack::PopAndDestroy( serviceNames );	

    CleanupStack::PopAndDestroy( &serviceIds );

    CSCENGDEBUG( "CCSCEngServiceHandler::ServiceNameL - end" );

    return iServiceName;

    }

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

// For getting brand id

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

//

EXPORT_C void CCSCEngServiceHandler::BrandIdL( 

    TUint aServiceId, TDes16& aBrandId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::BrandIdL - begin" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, EPropertyBrandId, *property ) );

    User::LeaveIfError( property->GetValue( aBrandId ) );

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG2( "CCSCEngServiceHandler::BrandIdL BRANDID=%S", &aBrandId );

    CSCENGDEBUG( "CCSCEngServiceHandler::BrandIdL - end" ); 

    }      

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

// For getting snap id

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

//

EXPORT_C TInt CCSCEngServiceHandler::SnapIdL( TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::SnapIdL - begin" ); 

    CSPProperty* property = CSPProperty::NewLC();

    TInt snapId( 0 );

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, ESubPropertyVoIPPreferredSNAPId, *property ) );

    User::LeaveIfError( property->GetValue( snapId ) );

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG( "CCSCEngServiceHandler::SnapIdL - end" ); 

    return snapId;

    }  

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

// For getting service setup plug-in id

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

//

EXPORT_C TInt32 CCSCEngServiceHandler::ServiceSetupPluginIdL( 

    TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::ServiceSetupPluginId - begin" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, EPropertyServiceSetupPluginId, *property ) );

    TInt serviceSetupPluginId( 0 );   

    User::LeaveIfError( property->GetValue( serviceSetupPluginId ) ); 

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG( "CCSCEngServiceHandler::ServiceSetupPluginId - end" ); 

    return serviceSetupPluginId;

    }      

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

// For getting service´s phonebook tab view id

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

//

EXPORT_C TInt CCSCEngServiceHandler::ServiceTabViewIdL( TUint aServiceId )

    {

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, EPropertyContactViewId, *property ) );

    TInt tabViewId( 0);                   

    User::LeaveIfError( property->GetValue( tabViewId ) );     

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG2( "CCSCEngServiceHandler::ServiceTabViewIdL: %d", tabViewId );

    return tabViewId;

    }      

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

// For getting service´s IM settings id.

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

//

EXPORT_C TInt CCSCEngServiceHandler::ImSettingsIdL( TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::ImSettingsIdL - begin" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, ESubPropertyIMSettingsId, *property ) );

    TInt settingsId( 0 );                   

    User::LeaveIfError( property->GetValue( settingsId ) );    

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG( "CCSCEngServiceHandler::ImSettingsIdL - end" );

    return settingsId;

    }  

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

// For setting service´s IM settings id.

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

//

EXPORT_C void CCSCEngServiceHandler::SetImSettingsIdL(

    TUint aServiceId, TInt aSettingsId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::SetImSettingsIdL - begin" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( 

        property->SetName( ESubPropertyIMSettingsId ) );

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

    iServiceSettings->AddOrUpdatePropertyL( aServiceId, *property );

    CleanupStack::PopAndDestroy( property );

    CSCENGDEBUG( "CCSCEngServiceHandler::SetImSettingsIdL - end" );

    } 

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

// For getting service´s presence request preference setting

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

//

EXPORT_C TOnOff CCSCEngServiceHandler::PresenceReqPrefL( TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::PresenceReqPrefL" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, ESubPropertyPresenceRequestPreference , *property ) );

    TOnOff onOff = EOn;    

    User::LeaveIfError( property->GetValue( onOff ) );

    CleanupStack::PopAndDestroy( property );

    return onOff;

    } 

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

// For setting service´s presence request preference setting

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

//

EXPORT_C void CCSCEngServiceHandler::SetPresenceReqPrefL( 

    TUint aServiceId, TOnOff aOnOff )

    {

    CSCENGDEBUG2( 

        "CCSCEngServiceHandler::SetPresenceReqPrefL: aOnOff=%d", aOnOff ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( 

        property->SetName( ESubPropertyPresenceRequestPreference ) );

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

    iServiceSettings->AddOrUpdatePropertyL( aServiceId, *property );

    CleanupStack::PopAndDestroy( property );

    } 

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

// For getting service´s handover notification tone preference setting

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

//

EXPORT_C TOnOff CCSCEngServiceHandler::HandoverNotifTonePrefL( 

    TUint aServiceId )

    {

    CSCENGDEBUG( "CCSCEngServiceHandler::HandoverNotifTonePrefL" ); 

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( iServiceSettings->FindPropertyL( 

        aServiceId, ESubPropertyVccHoNotificationToneMode , *property ) );

    RBuf value( 0 );  

    CleanupClosePushL( value );

    value.CreateL( 1 );

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

    // convert rbuf to int

    TInt intValue;

    TLex temp( value );

    User::LeaveIfError( temp.Val( intValue ) );

    CleanupStack::PopAndDestroy( &value );

    CleanupStack::PopAndDestroy( property );

    TOnOff onOff = EOONotSet;

    switch ( intValue )

        {

        case 0:

            {

            onOff = EOff;

            }

            break;

        case 1:

            {

            onOff = EOn;

            }

            break;

        default:

            {

            onOff = EOONotSet;

            }

            break;

        }

    CSCENGDEBUG2( "CCSCEngServiceHandler::HandoverNotifTonePrefL: %d", onOff ); 

    return onOff;

    }

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

// For setting service´s handover notification tone preference setting

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

//

EXPORT_C void CCSCEngServiceHandler::SetHandoverNotifTonePrefL( 

    TUint aServiceId, TOnOff aOnOff )

    {

    CSPProperty* property = CSPProperty::NewLC();

    User::LeaveIfError( 

        property->SetName( ESubPropertyVccHoNotificationToneMode ) );

    RBuf value;

    CleanupClosePushL( value );

    value.CreateL( 1 );

    value.AppendNum( aOnOff );

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

    iServiceSettings->AddOrUpdatePropertyL( aServiceId, *property );

    CleanupStack::PopAndDestroy( &value );

    CleanupStack::PopAndDestroy( property );

    }

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

// For finding out if service supports VCC

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

//

EXPORT_C TBool CCSCEngServiceHandler::IsVccSupportedL( TUint aServiceId )

    {

    TBool supported( EFalse );

    TInt vccServiceId( KErrNone );

    TInt error( KErrNone );

    //  Array of service provider IDs

    // is defined as: typedef RArray<TServiceId> RIdArray

    // in spdefinitions.h

    RIdArray serviceIdArray;     

    CleanupClosePushL( serviceIdArray );

    // This should leave if error occurs

    error = iServiceSettings->FindServiceIdsL( serviceIdArray );    

    User::LeaveIfError( error );

    TInt serviceId( KErrNone );

    TBool foundEntry( EFalse );

    for ( TInt i( 0 ); i < serviceIdArray.Count() && !foundEntry; i++ )

        {

        CSPProperty* property = CSPProperty::NewLC(); 

        error = iServiceSettings->FindPropertyL(

            serviceIdArray[i], ESubPropertyVccVDI, *property ); 

        if( error == KErrNone )

            {            

            vccServiceId =  serviceIdArray[i];

            foundEntry = ETrue;

            }

        CleanupStack::PopAndDestroy( property );

        }

    CleanupStack::PopAndDestroy( &serviceIdArray );

    if ( vccServiceId )

        {

        CSPProperty* property2 = CSPProperty::NewLC(); 

        iServiceSettings->FindPropertyL( 

            vccServiceId,

            ESubPropertyVccDtVoipServiceId,

            *property2 );

        TInt error = property2->GetValue( serviceId );

        User::LeaveIfError( error );

        CleanupStack::PopAndDestroy( property2 );

        }    

    if ( serviceId == aServiceId )

        {

        supported = ETrue;

        }

    CSCENGDEBUG2( "CCSCEngServiceHandler::IsVccSupportedL: %d", supported );

    return supported;

    }

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

// For finding out if service supports SIP/VoIP

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

//

EXPORT_C TBool CCSCEngServiceHandler::IsSipVoIPL( TUint aServiceId )

    {

    TBool sipVoIP( EFalse );