/*

* Copyright (c) 2004-2007 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:  Handles SIP settings in provisioning.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <CWPAdapter.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <wpsipadapter.rsg>

#include <utf.h>           // Unicode conversion

#include <WPAdapterUtil.h>

#include <sipmanagedprofileregistry.h>

#include <sipmanagedprofile.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include "CSIPProfileRegistryObserver.h"

#include "CWPSIPAdapter.h"      // own header

#include "CWPSIPItem.h"

#include "wpsipadapterdebug.h"

// CONSTANTS

_LIT( KSIPAdapterName,      "WPSIPAdapter" );

_LIT( KSIPAppID,            "w9010" );

_LIT8( KSIPAppID8,          "w9010" );

_LIT8( KDestinationNwAppId, "w904C" ); // Destination Network settings APPID

// SIP profile parameters, see w9010.txt

_LIT( KParmPTYPE,      "PTYPE");

_LIT( KParmPUID,       "PUID");

_LIT( KParmSIGNALCMPR, "SIGNALCMPR" );

_LIT( KParmSECNEG,     "SECNEG" );

_LIT( KParmLR,         "LR" );

_LIT( KParmLOCK,       "LOCK" );

_LIT( KParmAUTOREG,    "AUTOREG" );

_LIT( KParmSIGQOS,     "SIGQOS" );

// For other purposes.

const TUint32 KNotSet = 0xffffffff;

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

// CWPSIPAdapter::CWPSIPAdapter

// 

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

//

CWPSIPAdapter::CWPSIPAdapter() : CWPAdapter()

    {

    }

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

// CWPSIPAdapter::ConstructL

// 

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

//

void CWPSIPAdapter::ConstructL()

    {

    DBG_PRINT( "CWPSIPAdapter::ConstructL - begin" );

    TFileName fileName;

    Dll::FileName( fileName );

    iDefaultName = WPAdapterUtil::ReadHBufCL( fileName, KSIPAdapterName, 

        R_QTN_SM_DEFAULT_NAME_SIP );

    iTitle = WPAdapterUtil::ReadHBufCL( fileName, KSIPAdapterName, 

        R_QTN_SM_HEAD_SIP );

    iProviderIdDefault = WPAdapterUtil::ReadHBufCL( fileName, KSIPAdapterName,

        R_QTN_SM_PROVIDER );

    iSIPIdForDefault = KNotSet;

    DBG_PRINT( "CWPSIPAdapter::ConstructL - end" );

    }

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

// CWPSIPAdapter::NewL

// 

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

//

CWPSIPAdapter* CWPSIPAdapter::NewL()

    {

    CWPSIPAdapter* self = new( ELeave ) CWPSIPAdapter; 

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWPSIPAdapter::~CWPSIPAdapter

// 

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

//

CWPSIPAdapter::~CWPSIPAdapter()

    {

    DBG_PRINT( "CWPSIPAdapter::~CWPSIPAdapter - begin" );

    delete iTitle;

    delete iProviderIdDefault;

    delete iDefaultName;

    delete iCurrentSIPItem;

    iDatas.ResetAndDestroy();

    iDatas.Close();

    iSIPIdArray.Reset();

    iSIPIdArray.Close();

    DBG_PRINT( "CWPSIPAdapter::~CWPSIPAdapter - end" );

    }

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

// CWPSIPAdapter::ContextExtension

//

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

//

TInt CWPSIPAdapter::ContextExtension( MWPContextExtension*& aExtension )

    {

    aExtension = this;

    return KErrNone;

    }

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

// CWPSIPAdapter::SaveDataL

//

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

//

const TDesC8& CWPSIPAdapter::SaveDataL( TInt aIndex ) const

    {

    return iDatas[aIndex]->SaveData();

    }

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

// CWPSIPAdapter::DeleteL

//

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

//

void CWPSIPAdapter::DeleteL( const TDesC8& aSaveData )

    {

    TUint tId;

    TLex8 lex( aSaveData );

    TInt err( KErrNone );            

    err = lex.Val( tId );

    if ( KErrNone == err )

        {

        CSIPProfileRegistryObserver* cSIPProfileRegistryObserver = 

            CSIPProfileRegistryObserver::NewLC();

        CSIPManagedProfileRegistry*  cSIPManagedProfileRegistry  = 

            CSIPManagedProfileRegistry::NewLC( *cSIPProfileRegistryObserver );

        CSIPProfile* cProfile = NULL;

        cProfile = cSIPManagedProfileRegistry->ProfileL( tId );

        CleanupStack::PushL( cProfile );

        cSIPManagedProfileRegistry->DestroyL( *cProfile );

        CleanupStack::PopAndDestroy( cProfile );

        cProfile = NULL;

        CleanupStack::PopAndDestroy( cSIPManagedProfileRegistry );

        CleanupStack::PopAndDestroy( cSIPProfileRegistryObserver );

        }// if

    }

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

// CWPSIPAdapter::Uid

//

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

//

TUint32 CWPSIPAdapter::Uid() const

    {

    return iDtor_ID_Key.iUid; 

    }

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

// CWPSIPAdapter::DetailsL

//

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

//

TInt CWPSIPAdapter::DetailsL( TInt /*aItem*/, MWPPairVisitor& /*aVisitor */ )

    {

    return KErrNotSupported;

    }  

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

// CWPSIPAdapter::SummaryCount

//

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

//

TInt CWPSIPAdapter::ItemCount() const

    {

    return iDatas.Count();

    }

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

// CWPSIPAdapter::SummaryTitle

//

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

//

const TDesC16& CWPSIPAdapter::SummaryTitle( TInt /*aIndex*/ ) const

    {

    return *iTitle;

    }

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

// CWPSIPAdapter::SummaryText

//

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

//

const TDesC16& CWPSIPAdapter::SummaryText( TInt aIndex ) const

    {

    // If there is no value for NAME parameter the default value is set here.

    if ( iDatas[aIndex]->GetName().Length() == 0 )

        {

        TRAP_IGNORE( iDatas[aIndex]->SetNameL( iDefaultName->Des() ) );

        }

    return iDatas[aIndex]->GetName();

    }

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

// CWPSIPAdapter::SaveL

//

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

//

void CWPSIPAdapter::SaveL( TInt aIndex )

    {

    DBG_PRINT( "CWPSIPAdapter::SaveL - begin" );

    // Getting the SIP item (SIP profile data) at given index.

    CWPSIPItem* sipItem = iDatas[aIndex];

    if ( sipItem->GetNapDef() )

        {

        // Get WAP ID.

        TPckgBuf<TUint32> uid;

        uid.Copy( sipItem->GetNapDef()->Data( 0 ) );

        TUint32 wapId( uid() );

        // Get corresponding IAP ID.

        TUint32 iapId = IapIdFromWapIdL( wapId );

        sipItem->SetIAPId( iapId );

        }

    // If the PROVIDER-ID was not received the default value is set.

    if ( sipItem->GetProviderId().Length() == 0 )

        {

        HBufC8* tmpProviderId8 = HBufC8::NewLC( 

            iProviderIdDefault->Length() ); // CS:1

        TPtr8   ptrProviderId( tmpProviderId8->Des() );

        ptrProviderId.Copy( iProviderIdDefault->Des() );

        sipItem->SetProviderIdL( tmpProviderId8->Des() );

        CleanupStack::PopAndDestroy( tmpProviderId8 ); // CS:0

        }

    sipItem->StoreL();

    // Set WLAN availability state. Setting WLAN availability is done in

    // SavingFinalizedL().

    if ( sipItem->GetAutomaticRegistrationEnabled() )

        {

        iSIPIdArray.AppendL( sipItem->GetProfileId() );

        }

    DBG_PRINT( "CWPSIPAdapter::SaveL - end" );

    }

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

// CWPSIPAdapter::CanSetAsDefault

//

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

//

TBool CWPSIPAdapter::CanSetAsDefault( TInt /* aIndex */ ) const

    {

    TBool canSetAsDefault( 0 );

    TRAP_IGNORE( canSetAsDefault = CheckSettingAsDefaultL() );

    return canSetAsDefault;

    }

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

// CWPSIPAdapter::CheckSettingAsDefaultL

//

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

//

TBool CWPSIPAdapter::CheckSettingAsDefaultL() const

    {

    // Array of pointers to all loaded SIP profiles.

    CArrayPtrFlat<CSIPManagedProfile>* profiles;

    CSIPProfileRegistryObserver* cSIPProfileRegistryObserver = 

        CSIPProfileRegistryObserver::NewLC(); // CS:1

    CSIPManagedProfileRegistry*  cSIPManagedProfileRegistry = 

        CSIPManagedProfileRegistry::NewLC( *cSIPProfileRegistryObserver );

        // CS:2

    RArray<TSIPProfileTypeInfo> profileTypes;

    CleanupClosePushL( profileTypes ); // CS:3

     // Get the supported profile types.

    cSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes );

    // Create the profile pointer array.

    profiles = new ( ELeave ) CArrayPtrFlat<CSIPManagedProfile>( 5 );    

    TCleanupItem cleanupItem( CWPSIPItem::CleanupArrayItem, profiles );

    CleanupStack::PushL( cleanupItem ); // CS:4

    TInt i( 0 );

    RPointerArray<CSIPProfile> profilePointerArray;

    CleanupResetAndDestroyPushL( profilePointerArray ); // CS:5

    // Get all profiles based on profile types

    for ( i = 0; i < profileTypes.Count(); i++ )

        {        

        cSIPManagedProfileRegistry->ProfilesL( profileTypes[i], 

            profilePointerArray );

        TInt j( 0 );

        for ( j = 0; j < profilePointerArray.Count(); j++ )

            {

            CSIPManagedProfile* profile = 

                static_cast<CSIPManagedProfile*>( profilePointerArray[j] );

            profiles->AppendL( profile ); 

            }                    

        profilePointerArray.Reset();

        }

    TInt profileCount = profiles->Count();   

    // &profilePointerArray, profiles, &profileTypes,

    // cSIPManagedProfileRegistry, cSIPProfileRegistryObserver

    CleanupStack::PopAndDestroy( 5, cSIPProfileRegistryObserver ); // CS:0

    if ( profileCount > 1 )

        {

        // Adapter supports setting profile as default when there are at least

        // one profile stored before.

        return ETrue;

        }

    else

        {

        // First profile always gets default, no need to ask question in UI.

        return EFalse;

        }

    }

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

// CWPSIPAdapter::SetAsDefaultL

//

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

//

void CWPSIPAdapter::SetAsDefaultL( TInt /* aIndex */ )

    {

    // Set messages first profile as default

    iDatas[0]->SetAsDefaultL();

    iDatas[0]->StoreL();

    }

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

// CWPSIPAdapter::VisitL

//

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

//

void CWPSIPAdapter::VisitL( CWPCharacteristic& aCharacteristic )

    {

    switch( aCharacteristic.Type() )

        {

        case KWPApplication:

            iCurrentCharacteristic = KWPApplication;

            iCurrentSIPItem = CWPSIPItem::NewL();

            aCharacteristic.AcceptL( *this );

            if ( iAppID == KSIPAppID )

                {

                User::LeaveIfError( iDatas.Append( iCurrentSIPItem ) );

                }

            else

                {

                delete iCurrentSIPItem;

                }

            iCurrentSIPItem = NULL;

            break;

        case KWPResource:

            iCurrentCharacteristic = KWPResource;

			if ( iCurrentSIPItem )

                {                

                aCharacteristic.AcceptL( *this );

                }

            break;

        case KWPNapDef:

            iCurrentCharacteristic = KWPNapDef;

			if ( iCurrentSIPItem )

                {                

                aCharacteristic.AcceptL( *this );

                }

            break;

        case KWPAppAddr:

            iCurrentCharacteristic = KWPAppAddr;

            if ( iCurrentSIPItem )

                {                

                aCharacteristic.AcceptL( *this );

                }

            break;

        case KWPPort:

            iCurrentCharacteristic = KWPPort;

            if ( iCurrentSIPItem )

                {                

                aCharacteristic.AcceptL( *this );

                }

            break;

        case KWPAppAuth:

            iCurrentCharacteristic = KWPAppAuth;

			if ( iCurrentSIPItem )

                {                

                aCharacteristic.AcceptL( *this );

                }

            break;

        default:

            break;

        }

    }

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

// CWPSIPAdapter::VisitL

//

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

//

void CWPSIPAdapter::VisitL( CWPParameter& aParameter )

    {

    DBG_PRINT("CWPSIPAdapter::VisitL( parameter ) - begin");

    if ( !iCurrentSIPItem )

        {

        User::Leave( KErrGeneral );

        }

    // tmpValue is created for holding value converted from Unicode to UTF8.

    HBufC8* tmpValue;

    tmpValue = HBufC8::NewL( aParameter.Value().Length() );

    CleanupStack::PushL( tmpValue ); // CS:1

    TPtr8 ptrTmpValue( tmpValue->Des() );

    ptrTmpValue.Copy( aParameter.Value() );

    switch ( aParameter.ID() )

        {

        case EWPParameterAppID:

            {

		    iAppID.Set( aParameter.Value() );

            break;

            }

        // Here case 0 are handled the SIP parameters that are extensions to 

        // OMA Client Provisioning parameter set.

        case 0:

            {

            if ( aParameter.Name() == KParmPTYPE )

                {

                iCurrentSIPItem->SetProfileTypeL( tmpValue->Des() );

                }

            else if ( aParameter.Name() == KParmPUID && 

                iCurrentSIPItem->GetAOR().Length() == 0 )

                {

                iCurrentSIPItem->SetAORL( tmpValue->Des() );

                }

            else if ( aParameter.Name() == KParmSIGNALCMPR && 

                iCurrentSIPItem->GetSignalCompressionEnabled() == EFalse )

                {

                iCurrentSIPItem->SetSignalCompressionEnabled( ETrue );

                }

            else if ( aParameter.Name() == KParmSECNEG && 

                iCurrentSIPItem->GetSecurityNegotiationEnabled() == EFalse )

                {

                iCurrentSIPItem->SetSecurityNegotiationEnabled( ETrue );

                }

            // Extensions to OMA parameters in APPDDR characteristics    

            else if ( aParameter.Name() == KParmLR && iCurrentSIPItem->

                GetLooseRoutingForOutboundConnectionEnabled() == EFalse ) 

                {

                iCurrentSIPItem->SetLooseRoutingForOutboundConnectionEnabled( 

                    ETrue );

                }

            else if ( aParameter.Name() == KParmLOCK ) 

                {

                iCurrentSIPItem->SetProfileLockEnabled( ETrue );

                }

            else if ( aParameter.Name() == KParmAUTOREG && iCurrentSIPItem->

                GetAutomaticRegistrationEnabled() == EFalse ) 

                {

                iCurrentSIPItem->SetAutomaticRegistrationEnabled( ETrue );

                }

            else if ( aParameter.Name() == KParmSIGQOS )

                {

                TUint32 parmVal;

                TLex8 lex( tmpValue->Des() );

                TInt err( KErrNone );

                err = lex.Val( parmVal, EDecimal );

                if ( KErrNone == err )

                    {

                    iCurrentSIPItem->SetSigQos( parmVal );

                    }

                }

            break;

            }

        case EWPParameterAppRef:

            {

            if ( iCurrentSIPItem->GetAppRef().Length() == 0 )

                {

                iCurrentSIPItem->SetAppRefL( tmpValue->Des() );

                }// if

            break;

            }

        case EWPParameterURI:

            {

            if ( iCurrentCharacteristic == KWPResource && 

                iCurrentSIPItem->GetRegistrarAddr().Length() == 0 )

                {

                iCurrentSIPItem->SetRegistrarAddrL( tmpValue->Des() );

                }// if

            break;

            }

        case EWPParameterToNapID:

            {

            if ( iCurrentCharacteristic == KWPApplication && 

                iCurrentSIPItem->GetNapDefName().Length() == 0 )

                {