/*
* Copyright (c) 2007-2008 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:  implementation of CSPSsSettingsHandler class.
*
*/


// INCLUDES
#include "cspsssettingshandler.h"
#include "csplogger.h"
#include "csppanic.pan"

#include <etelmm.h>
#include <mccpssobserver.h>


// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::CSPSsSettingsHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSPSsSettingsHandler::CSPSsSettingsHandler( const MCCPSsObserver& aObs ) : 
        iObserver( const_cast<MCCPSsObserver&>(aObs) )
    {
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::CSPSsSettingsHandler" );
    } 

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::ConstructL()
    {
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::ConstructL <" );
    User::LeaveIfError( iSSSettings.Open() );
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::ConstructL Reg " );
    TInt errorCode = iSSSettings.Register( ESSSettingsAls, *this );
    CSPLOGSTRING2( CSPINT, 
            "CSPSsSettingsHandler::ConstructL > iSSSettings.Register, errorCode: %d",
            errorCode );
    if ( errorCode == KErrNotSupported )
        {
        CSPLOGSTRING( CSPINT, "CSPSsSettingsHandler::ConstructL, ALS not supported" );
        }
    else if ( errorCode == KErrNotReady )
        {
        // Try again after idle
        iRegisterAlsNofify = CIdle::NewL( CActive::EPriorityHigh );
        RegisterAfterIdle();
        }    
      
    RMobilePhone::TMobilePhoneALSLine alsLine;
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::ConstructL GetALS" );
    GetALSLineL( alsLine );
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::ConstructL Notify " );
    iObserver.NotifyCurrentActiveALSLine( (TInt) alsLine );
       
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::ConstructL >" );
    } 

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSPSsSettingsHandler* CSPSsSettingsHandler::NewL( const MCCPSsObserver& aObs )
    {
    CSPSsSettingsHandler* self = new ( ELeave ) CSPSsSettingsHandler( aObs );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::NewL" );
    return self;
    } 

// Destructor
CSPSsSettingsHandler::~CSPSsSettingsHandler()
    {
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::~CSPSsSettingsHandler <" );
    iSSSettings.Close();
    CSPLOGSTRING( CSPOBJECT, "CSPSsSettingsHandler::~CSPSsSettingsHandler >" );
    if ( iRegisterAlsNofify )
        {
        delete iRegisterAlsNofify;
        }
    }

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::GetALSLineL
// Sends synchronous request to get the ALS line and returns handle to access 
// the status.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::GetALSLineL(
        RMobilePhone::TMobilePhoneALSLine& aALSLine )
    {
    TInt value;
    User::LeaveIfError( iSSSettings.Get( ESSSettingsAls, value ) );

    TSSSettingsAlsValue alsValue = 
        static_cast< TSSSettingsAlsValue > ( value );

    switch( alsValue )
        {
        case ESSSettingsAlsNotSupported:
            aALSLine = RMobilePhone::EAlternateLineNotAvailable;
            break;
        case ESSSettingsAlsPrimary: 
            aALSLine = RMobilePhone::EAlternateLinePrimary;       
            break;
        case ESSSettingsAlsAlternate:
            aALSLine = RMobilePhone::EAlternateLineAuxiliary;
            break;
        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::SetALSLineL
// Sends synchronous request to set the ALS line and returns handle to access 
// the status.
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::SetALSLineL(
        RMobilePhone::TMobilePhoneALSLine& aALSLine )
    {
    TSSSettingsAlsValue alsValue = 
        static_cast<TSSSettingsAlsValue> ( aALSLine );
        
    switch( aALSLine )
        {
        case RMobilePhone::EAlternateLineUnknown:
        case RMobilePhone::EAlternateLineNotAvailable:
            alsValue = ESSSettingsAlsNotSupported;
            break;
        case RMobilePhone::EAlternateLinePrimary: 
            alsValue = ESSSettingsAlsPrimary;       
            break;
        case RMobilePhone::EAlternateLineAuxiliary:
            alsValue = ESSSettingsAlsAlternate;
            break;
        default:
            CSPLOGSTRING( CSPINT,
                "CSPSsSettingsHandler::SetALSLineL: Not valid value" );
            __ASSERT_DEBUG( EFalse, Panic( ECSPPanicInvalidRequest ) );
            break;
        }
    User::LeaveIfError( iSSSettings.Set( ESSSettingsAls, alsValue ) );
    } 

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::GetClirL
// Sends synchronous request to get the CLIR value and returns handle to access 
// the status.
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::GetClirL(
        RMobileCall::TMobileCallIdRestriction& aClir )
    {
    TInt value;
    User::LeaveIfError( iSSSettings.Get( ESSSettingsClir, value ) );

    TSSSettingsClirValue clir = 
        static_cast<TSSSettingsClirValue> ( value );
    CSPLOGSTRING2( CSPERROR,
        "CSPSsSettingsHandler::GetClirL, clir: %d", clir );
        
    switch( clir )
        {
        case ESSSettingsClirNetworkDefault:
            aClir = RMobileCall::EIdRestrictDefault;
            break;
        case ESSSettingsClirExplicitInvoke: 
            aClir = RMobileCall::EDontSendMyId;
            break;
        case ESSSettingsClirExplicitSuppress:
            aClir = RMobileCall::ESendMyId; 
            break;
        default:
            CSPLOGSTRING2( CSPERROR,
                "CSPSsSettingsHandler::GetClirL, NOT VALID aClir: %d", aClir );
            __ASSERT_DEBUG( EFalse, Panic( ECSPPanicInvalidRequest ) );
            break;
        }
    }

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::GetCugL
// Sends synchronous request to get the CUG index and returns handle to access 
// the status.
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::GetCugL( TInt& aCugIndex )
    {
    CSPLOGSTRING2( CSPINT,
        "CSPSsSettingsHandler::GetCugL, aCugIndex: %d", aCugIndex );
    User::LeaveIfError( iSSSettings.Get( ESSSettingsCug, aCugIndex ) );
    }
    
// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::GetDefaultCugL
// Sends synchronous request to get the default CUG index 
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::GetDefaultCugL( TInt& aDefCug )
    {
    User::LeaveIfError( iSSSettings.Get( ESSSettingsDefaultCug, aDefCug ) );
    }

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::IsValueValidCugIndex
// Sends synchronous request to check the CUG index 
// -----------------------------------------------------------------------------
//
TBool CSPSsSettingsHandler::IsValueValidCugIndex( const TInt& aValue ) const
    {
    return iSSSettings.IsValueValidCugIndex( aValue );
    }

// ---------------------------------------------------------
// CSPSsSettingsHandler::PhoneSettingChanged
// ---------------------------------------------------------
//
void CSPSsSettingsHandler::PhoneSettingChanged( 
        TSSSettingsSetting aSetting, 
        TInt aNewValue )
    {
    CSPLOGSTRING2( CSPINT,
        "CSPSsSettingsHandler::PhoneSettingChanged, aNewValue : %d",
        aNewValue );
    if ( aSetting == ESSSettingsAls )
        {
        TSSSettingsAlsValue alsValue = 
            static_cast< TSSSettingsAlsValue > ( aNewValue );
    
        RMobilePhone::TMobilePhoneALSLine 
            alsLine( RMobilePhone::EAlternateLineUnknown );

        switch( alsValue )
            {
            case ESSSettingsAlsNotSupported:
                alsLine = RMobilePhone::EAlternateLineNotAvailable;
                break;
            case ESSSettingsAlsPrimary: 
                alsLine = RMobilePhone::EAlternateLinePrimary;       
                break;
            case ESSSettingsAlsAlternate:
                alsLine = RMobilePhone::EAlternateLineAuxiliary;
                break;
            default:
                break;
            }
        
        iObserver.NotifyCurrentActiveALSLine( (TInt) alsLine );
        }
    }

// -----------------------------------------------------------------------------
// CSPSsSettingsHandler::RegisterAfterIdle
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::RegisterAfterIdle()
    {
    CSPLOGSTRING( CSPINT, "CSPSsSettingsHandler::RegisterAfterIdle" );
    if ( !iRegisterAlsNofify->IsActive() )
        {
        CSPLOGSTRING( CSPINT, "CSPSsSettingsHandler::RegisterAfterIdle > iRegisterAlsNofify->Star" );
        iRegisterAlsNofify->Start( 
            TCallBack( CIdleCallBack, this ) );
        }
    }
    
// -----------------------------------------------------------------------------
// CSProvider::CIdleCallBack
// -----------------------------------------------------------------------------
//
TInt CSPSsSettingsHandler::CIdleCallBack( TAny* aAny )
    {
    CSPLOGSTRING( CSPINT, "CSPSsSettingsHandler::CIdleCallBack" );
    static_cast< CSPSsSettingsHandler* >( aAny )->Register();

    return KErrNone;    
    }   

// -----------------------------------------------------------------------------
// CSProvider::Register
// -----------------------------------------------------------------------------
//
void CSPSsSettingsHandler::Register()
    {
    CSPLOGSTRING( CSPINT, "CSPSsSettingsHandler::Register" );
    TInt errorCode( KErrNotReady );
    
    errorCode = iSSSettings.Register( ESSSettingsAls, *this );
    CSPLOGSTRING2( CSPINT, 
        "CSPSsSettingsHandler::Register > iSSSettings.Register, errorCode: %d",
        errorCode );

    if ( errorCode == KErrNotReady )
        {
        // Try again
        RegisterAfterIdle();
        }
    }  

//  End of file