/*

* Copyright (c) 2006 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:  Adapter to the SUPL Settings API

*

*/

// System Includes

#include <epos_csuplsettings.h>

#include <locsuplsettingsui.rsg>

#include <StringLoader.h>

// User Includes

#include "locsuplsettingsadapter.h"

#include "locsuplsettingsadapterobserver.h"

#include "locsuplsettingssessionobserver.h"

#include "locsupldebug.h"

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

// Private Constructor

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

//

CLocSUPLSettingsAdapter::CLocSUPLSettingsAdapter( 

                            MLocSUPLSettingsAdapterObserver&    aObserver )

		:CActive( EPriorityStandard ),

		iObserver( aObserver )

    {

    }

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

// Destructor

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

//    

CLocSUPLSettingsAdapter::~CLocSUPLSettingsAdapter()

    {

	DEBUG( + CLocSUPLSettingsAdapter::~CLocSUPLSettingsAdapter );	

    Cancel();

    if( iSUPLSettings )

        {

        iSUPLSettings->RemoveObserver();

        iSUPLSettings->RemoveSessionObserver();

        }

    delete iSUPLSettings;

    iSUPLSettings = NULL;

    delete iAutomatic;

    iAutomatic = NULL;

    delete iAutomaticatHome;

    iAutomaticatHome = NULL;

    delete iAsk;

    iAsk = NULL;

    delete iDisable;

    iDisable = NULL;

	DEBUG( - CLocSUPLSettingsAdapter::~CLocSUPLSettingsAdapter );	

    } 

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

// CLocSUPLSettingsAdapter* CLocSUPLSettingsAdapter::NewL

// Static Two phase contructor that instantiates the CLocSUPLSettingsAdapter

// 

// @param aObserver				    Observer to the SUPL settings adapter

// @return CLocSUPLSettingsAdapter*	Reference to the object created

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

//    

CLocSUPLSettingsAdapter* CLocSUPLSettingsAdapter::NewL(

                            MLocSUPLSettingsAdapterObserver&    aObserver )

    {

	DEBUG( + CLocSUPLSettingsAdapter::NewL );	

    CLocSUPLSettingsAdapter* self = 

                new ( ELeave ) CLocSUPLSettingsAdapter( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

	DEBUG( - CLocSUPLSettingsAdapter::NewL );	

    return self;

    }

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

// void CLocSUPLSettingsAdapter::ConstructL

// Second phase of the two phase constructor

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

// 

void CLocSUPLSettingsAdapter::ConstructL()

    {

	DEBUG( + CLocSUPLSettingsAdapter::ConstructL );	

    // Create the SUPL Settings

    iSUPLSettings = CSuplSettings::NewL();

    // Set the Observer for SUPL Settings

    iSUPLSettings->SetObserverL( *this );

    // Set the Observer for SUPL Sessions

    iSUPLSettings->SetSessionObserverL( *this );

    // Load the SUPL settings usage strings

    iAutomatic 			= StringLoader::LoadL( R_LOC_SUPL_AUTOMATIC );

    iAutomaticatHome 	= StringLoader::LoadL( R_LOC_SUPL_HOME_AUTOMATIC );

    iAsk 				= StringLoader::LoadL( R_LOC_SUPL_ASK );

    iDisable 			= StringLoader::LoadL( R_LOC_SUPL_DISABLED );

    CActiveScheduler::Add( this );

	DEBUG( - CLocSUPLSettingsAdapter::ConstructL );	

    }           

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

// void CLocSUPLSettingsAdapter::Initialize

// Initializes the SUPL Settings API. This is an asynchronus call, the call

// back for which is given through the observer

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

//

void CLocSUPLSettingsAdapter::Initialize()

    {

	DEBUG( + CLocSUPLSettingsAdapter::Initialize );	

    if( !IsActive())

        {

        iSUPLSettings->Initialize( iStatus );

        SetActive();

        }

	DEBUG( - CLocSUPLSettingsAdapter::Initialize );	

    }

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

// void CLocSUPLSettingsAdapter::CancelInitialize

// Cancels the Initialization

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

//

void CLocSUPLSettingsAdapter::CancelInitialize()

    {

    Cancel();

    }

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

// void CLocSUPLSettingsAdapter::SetSuplUsageL

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

//       

void CLocSUPLSettingsAdapter::SetSuplUsageL( 

            const CLocSUPLSettingsAdapter::TLocSuplUsage    aIndex )

    {

	DEBUG( + CLocSUPLSettingsAdapter::SetSuplUsageL );	

    CSuplSettings::TSuplSettingsUsage value = CSuplSettings::ESuplUsageAlwaysAsk;

    switch ( aIndex )

        {

        case ELocSuplAutomatic:

            {

            value = CSuplSettings::ESuplUsageAutomatic;

            break;

            }

        case ELocSuplAutomaticatHome:

            {

            value = CSuplSettings::ESuplUsageHomeAutomatic;

            break;

            }

        case ELocSuplAlwaysAsk:

            {

            value = CSuplSettings::ESuplUsageAlwaysAsk;

            break;

            }

        case ELocSuplDisable:

            {

            value = CSuplSettings::ESuplUsageDisabled;

            break;

            }

        default:

            {

            User::Leave( KErrNotFound );

            break;    

            }

        }

    // Write back to the SUPL settings API

    TInt ret = iSUPLSettings->SetSuplUsage( value );            

    // If the Set failed, then Leave with the corresponding Error code

    if( ret )

        {

        User::Leave ( ret );

        }

	DEBUG( - CLocSUPLSettingsAdapter::SetSuplUsageL );	

    }

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

// void CLocSUPLSettingsAdapter::GetSuplUsageL

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

//  

void CLocSUPLSettingsAdapter::GetSuplUsageL( TDes&    aSuplUsage )

    {

	DEBUG( + CLocSUPLSettingsAdapter::GetSuplUsageL );	

    CSuplSettings::TSuplSettingsUsage value = CSuplSettings::ESuplUsageAlwaysAsk;

    User::LeaveIfError( iSUPLSettings->GetSuplUsage( value ));

    switch ( value )

        {

        case CSuplSettings::ESuplUsageAutomatic:

            {

            if ( aSuplUsage.MaxLength() < iAutomatic->Des().Length())

                {

                User::Leave( KErrNoMemory );

                }

            aSuplUsage.Copy( *iAutomatic );

            break;

            }

        case CSuplSettings::ESuplUsageHomeAutomatic:

            {

            if ( aSuplUsage.MaxLength() < iAutomaticatHome->Des().Length())

                {

                User::Leave( KErrNoMemory );

                }

            aSuplUsage.Copy( *iAutomaticatHome );          

            break;

            }

        case CSuplSettings::ESuplUsageAlwaysAsk:

            {

            if ( aSuplUsage.MaxLength() < iAsk->Des().Length())

                {

                User::Leave( KErrNoMemory );

                }            

            aSuplUsage.Copy( *iAsk );

            break;

            }

        case CSuplSettings::ESuplUsageDisabled:

            {

            if ( aSuplUsage.MaxLength() < iDisable->Des().Length())

                {

                User::Leave( KErrNoMemory );

                }

            aSuplUsage.Copy( *iDisable );

            break;

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

	DEBUG( - CLocSUPLSettingsAdapter::GetSuplUsageL );	

    }

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

// TLocSuplUsage CLocSUPLSettingsAdapter::GetSuplUsage

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

// 

TInt CLocSUPLSettingsAdapter::GetSuplUsage()

    {

	DEBUG( + CLocSUPLSettingsAdapter::GetSuplUsage TInt );	

    CSuplSettings::TSuplSettingsUsage value = CSuplSettings::ESuplUsageAlwaysAsk;

    TInt error = iSUPLSettings->GetSuplUsage( value );

    if ( error )

        {

        // If there is an error then return the default value

        return CSuplSettings::ESuplUsageAlwaysAsk;

        }

	DEBUG( - CLocSUPLSettingsAdapter::GetSuplUsage TInt );	

    return value;

    }

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

// TLocSuplUsage CLocSUPLSettingsAdapter::GetSuplUsageIndex

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

// 

CLocSUPLSettingsAdapter::TLocSuplUsage CLocSUPLSettingsAdapter::GetSuplUsageIndex()

    {    

	DEBUG( + CLocSUPLSettingsAdapter::GetSuplUsageIndex );	

    TLocSuplUsage index = ELocSuplAutomatic;

    CSuplSettings::TSuplSettingsUsage value = CSuplSettings::ESuplUsageAlwaysAsk;

    if ( iSUPLSettings->GetSuplUsage( value ))

        {

        // If there is an error then return the default value.

        return index;

        }

    switch ( value )

        {

        case CSuplSettings::ESuplUsageAutomatic:

            {

            index = ELocSuplAutomatic;

            break;

            }

        case CSuplSettings::ESuplUsageHomeAutomatic:

            {

            index = ELocSuplAutomaticatHome;         

            break;

            }

        case CSuplSettings::ESuplUsageAlwaysAsk:

            {

            index = ELocSuplAlwaysAsk;

            break;

            }

        case CSuplSettings::ESuplUsageDisabled:

            {

            index = ELocSuplDisable;

            break;

            }

        default:

            {

            break;

            }

        }

    return index;   

    }

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

// const TDesC& CLocSUPLSettingsAdapter::Automatic

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

// 

const TDesC& CLocSUPLSettingsAdapter::Automatic()

    {

    return *iAutomatic;

    }

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

// const TDesC& CLocSUPLSettingsAdapter::AutomaticAtHome

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

//

const TDesC& CLocSUPLSettingsAdapter::AutomaticAtHome()

    {

    return *iAutomaticatHome;  

    }

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

// const TDesC& CLocSUPLSettingsAdapter::AlwaysAsk

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

//

const TDesC& CLocSUPLSettingsAdapter::AlwaysAsk()

    {

    return *iAsk;   

    }

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

// const TDesC& CLocSUPLSettingsAdapter::Disable

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

//

const TDesC& CLocSUPLSettingsAdapter::Disable()

    {

    return *iDisable; 

    }

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

// void CLocSUPLSettingsAdapter::HandleSuplSettingsChangeL

// Handle the Settings UI changes

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

//     

void CLocSUPLSettingsAdapter::HandleSuplSettingsChangeL( 

                TSuplSettingsEventType /*aEvent*/,

                TInt /*aSlpId*/                         

        		)

    {

	DEBUG( + CLocSUPLSettingsAdapter::HandleSuplSettingsChangeL );	

    iObserver.HandleSuplSettingsChangeL( 

                    MLocSUPLSettingsAdapterObserver::ESUPLSettingsChanged );

	DEBUG( - CLocSUPLSettingsAdapter::HandleSuplSettingsChangeL );	

    }

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

// void CLocSUPLSettingsAdapter::HandleSuplSessionChangeL

// Handle the Supl Session changes

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

//     

void CLocSUPLSettingsAdapter::HandleSuplSessionChangeL( 

                TSuplSessionEventType aEvent,

                TInt64 aSessionId                        

        		)

    {

	DEBUG( + CLocSUPLSettingsAdapter::HandleSuplSessionChangeL );	

	if( iSessionObserver && iSessionObserver->SessionId() == aSessionId )

		{

		MLocSUPLSettingsSessionObserver::TUpdateType updateType = 

                            MLocSUPLSettingsSessionObserver::ESessionModified;

		if( MSuplSessionObserver::ESuplSessionDBDeleteEvent == aEvent )

		    updateType = MLocSUPLSettingsSessionObserver::ESessionDeleted;

		iSessionObserver->UpdateSessionL( updateType );

		}

    iObserver.HandleSuplSettingsChangeL( 

                    MLocSUPLSettingsAdapterObserver::ESUPLSettingsChanged );

	DEBUG( - CLocSUPLSettingsAdapter::HandleSuplSessionChangeL );	

    }

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

// void CLocSUPLSettingsAdapter::RunL

// Inherited from CActive

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

// 

void CLocSUPLSettingsAdapter::RunL()

    {

	DEBUG( + CLocSUPLSettingsAdapter::RunL );	

    // If the SUPL settings API has been successfull initalized then a success

    // call back needs to be issued. In all other cases, other than a KErrCancel

    // it is assumed that the initailization has failed.

    if( iStatus.Int() == KErrNone )

        {        

        iObserver.HandleSuplSettingsChangeL( 

                    MLocSUPLSettingsAdapterObserver::ESUPLSettingsIntialized );

        }

    else if( iStatus.Int() != KErrCancel )

        {

        iObserver.HandleSuplSettingsChangeL( 

                    MLocSUPLSettingsAdapterObserver::ESUPLSettingsInitalizeError );    

        }

	DEBUG( - CLocSUPLSettingsAdapter::RunL );	

    }

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

// void CLocSUPLSettingsAdapter::DoCancel

// Inherited from CActive

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

//     

void CLocSUPLSettingsAdapter::DoCancel()

    {

    iSUPLSettings->CancelInitialize();

    }

//***************************************************************************

//  

//  @since S60 9.1TB 

// 

// ***************************************************************************

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

// void CLocSUPLSettingsAdapter::AddNewServerL

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

// 

void CLocSUPLSettingsAdapter::AddNewServerL( 

        const TDesC& aServerAddress,

        const TDesC& aIapName,

        const TBool aUsageInHomeNw

		)

	{

	DEBUG( + CLocSUPLSettingsAdapter::AddNewServerL );	

	CServerParams* serverParam = CServerParams::NewL();

						aServerAddress, 

						aIapName, 

						ETrue, 

						EFalse, // default value

						aUsageInHomeNw, 

	TInt64 slpId;	

	User::LeaveIfError( iSUPLSettings->AddNewServer( serverParam, slpId ) );							

	DEBUG( - CLocSUPLSettingsAdapter::AddNewServerL );	

	}

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

// void CLocSUPLSettingsAdapter::RemoveServerL

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

// 

void CLocSUPLSettingsAdapter::RemoveServerL(

		const TInt64 aSlpId

		)

	{

	DEBUG( + CLocSUPLSettingsAdapter::RemoveServerL );	

	User::LeaveIfError( iSUPLSettings->RemoveServer( aSlpId ) );

	DEBUG( - CLocSUPLSettingsAdapter::RemoveServerL );	

	}

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

// void CLocSUPLSettingsAdapter::GetAllSlpL

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

// 

void CLocSUPLSettingsAdapter::GetAllSlpL(

        RPointerArray<CServerParams>& aParamValues

		) const

	{

	DEBUG( + CLocSUPLSettingsAdapter::GetAllSlpL );	

	User::LeaveIfError( iSUPLSettings->GetAllSlp( aParamValues ) );

	DEBUG( - CLocSUPLSettingsAdapter::GetAllSlpL );	

	}

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

// void CLocSUPLSettingsAdapter::GetSlpInfoFromIdL

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

// 

void CLocSUPLSettingsAdapter::GetSlpInfoFromIdL(

	            const TInt64 aSlpId, 

	            CServerParams *aParamValues

	    ) const

	{

	DEBUG( + CLocSUPLSettingsAdapter::GetSlpInfoFromIdL );	

	User::LeaveIfError( iSUPLSettings->GetSlpInfoFromId( aSlpId, aParamValues ) );	

	DEBUG( - CLocSUPLSettingsAdapter::GetSlpInfoFromIdL );	

	}

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

// void CLocSUPLSettingsAdapter::ChangePriorityL

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

// 

void CLocSUPLSettingsAdapter::ChangePriorityL(

        TInt64 aSlpId, 

        TInt aPriority,

        TBool aDirection

		)

	{

	DEBUG( + CLocSUPLSettingsAdapter::ChangePriorityL );	

	User::LeaveIfError( 

		iSUPLSettings->ChangePriority( aSlpId, aPriority, aDirection ) );		

	DEBUG( - CLocSUPLSettingsAdapter::ChangePriorityL );	

	}

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

// void CLocSUPLSettingsAdapter::SetServerAddressL

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

// 

void CLocSUPLSettingsAdapter::SetServerAddressL( 

        const TInt64 aSlpId, 

        const TDesC& aServerAddress