/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 white list settings in provisioning.

*

*/

// INCLUDE FILES

	// User includes

#include "PushInitiator.h"

#include "PushInitiatorList.h"

#include "PushMtmSettings.h"

#include "WhiteListAdapter.h"

#include "WhiteListAdapterDef.h"

#include "WhiteListAdapterItem.h"

#include "WhiteListAdapterLogger.h"

#include "WhiteListAdapterPanic.h"

#include "WhiteListAdapterUids.h"

	// System includes

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

// CONSTANTS

// 'Push enabled' flag settings

const TInt KPushEnabledFlagLength = 1;

const TUint16 KPushEnabledFlagTrue = '1';

const TUint16 KPushEnabledFlagFalse = '0';

// Granularity value for dynamic arrays

const TInt KDynamicArrayGranularity = 3;

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

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

// CWhiteListAdapter::CWhiteListAdapter

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

//

CWhiteListAdapter::CWhiteListAdapter() : CWPAdapter(),

iItems( KDynamicArrayGranularity ),

iItemsToBeAdded( KDynamicArrayGranularity ),

iLogicalProxyPushSupport( EPushDontCare ), iPhysicalProxyIsVisited( EFalse )

	{

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter c'tor" ) ) );

	}

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

// CWhiteListAdapter::ConstructL

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

//

void CWhiteListAdapter::ConstructL()

	{

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "-> WhiteListAdapter::ConstructL" ) ) );

    iMsvSession = CMsvSession::OpenSyncL( *this );

	iPushMtmSettings = CPushMtmSettings::NewL();

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "<- WhiteListAdapter::ConstructL" ) ) );

	}

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

// CWhiteListAdapter::NewL

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

//

CWhiteListAdapter* CWhiteListAdapter::NewL()

	{

	CWhiteListAdapter* self = new (ELeave) CWhiteListAdapter;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop();	// self

	return self;

	}

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

// CWhiteListAdapter::~CWhiteListAdapter

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

//

CWhiteListAdapter::~CWhiteListAdapter()

	{

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "-> WhiteListAdapter d'tor" ) ) );

	delete iCurrentItem;

	delete iPushMtmSettings; // It has to be deleted before iMsvSession, 

    // because it uses iMsvSession->FileSession().

	delete iMsvSession;

    CLOG( ( ELogDetailed, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter d'tor, iItemsToBeAdded.Count:%d" ),

        iItemsToBeAdded.Count() ) );

    iItemsToBeAdded.ResetAndDestroy();

    iItemsToBeAdded.Close();

    CLOG( ( ELogDetailed, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter d'tor, iItems.Count:%d" ), iItems.Count() ) );

	iItems.ResetAndDestroy();

	iItems.Close();

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "<- WhiteListAdapter d'tor" ) ) );

	}

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

// CWhiteListAdapter::ItemCount

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

//

TInt CWhiteListAdapter::ItemCount() const

	{

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter::ItemCount %d" ), iItems.Count() ) );

	return iItems.Count();

	}

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

// CWhiteListAdapter::SummaryTitle

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

//

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

	{

    // As WL text will never be shown, we simply return an empty string here.

	return KNullDesC16();

	}

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

// CWhiteListAdapter::SummaryText

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

//

const TDesC16& CWhiteListAdapter::SummaryText( TInt /*aIndex*/ ) const

	{

    // As WL text will never be shown, we simply return an empty string here.

	return KNullDesC16();

	}

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

// CWhiteListAdapter::SaveL

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

//

void CWhiteListAdapter::SaveL( TInt aItem )

	{

	__ASSERT_DEBUG( 0 <= aItem && aItem < iItems.Count(),

				Panic( EArrayIndexOutOfBounds ) );

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "-> WhiteListAdapter::SaveL %d" ), aItem ) );

	CPushInitiator* pi = new (ELeave) CPushInitiator;

	CleanupStack::PushL( pi );

	pi->SetAddressL( iItems[aItem]->Address(),

					 iItems[aItem]->AddressType() );

	TUint32 entryId = iPushMtmSettings->PushInitiatorList().AddL( pi );

	CleanupStack::Pop( pi );	// pi, ownership taken over

    // Save the ID of the added entry:

    iItems[aItem]->SetId( entryId );

	iPushMtmSettings->SaveL();

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "<- WhiteListAdapter::SaveL" ) ) );

    }

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

// CWhiteListAdapter::CanSetAsDefault

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

//

TBool CWhiteListAdapter::CanSetAsDefault( TInt /*aItem*/ ) const

	{

	return EFalse;

	}

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

// CWhiteListAdapter::SetAsDefaultL

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

//

void CWhiteListAdapter::SetAsDefaultL( TInt /*aItem*/ )

	{

	}

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

// CWhiteListAdapter::DetailsL

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

//

TInt CWhiteListAdapter::DetailsL( TInt /*aItem*/,

                                  MWPPairVisitor& /*aVisitor*/ )

	{

	return KErrNotSupported;

	}

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

// CWhiteListAdapter::ContextExtension

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

//

TInt CWhiteListAdapter::ContextExtension( MWPContextExtension*& aExtension )

    {

    aExtension = this;

    return KErrNone;

    }

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

// CWhiteListAdapter::VisitL

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

//

void CWhiteListAdapter::VisitL( CWPCharacteristic& aCharacteristic )

	{

	if ( aCharacteristic.Type() == KWPPxLogical )

		{

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "-> WhiteListAdapter::VisitL PXLOGICAL" ) ) );

		aCharacteristic.AcceptL( *this );

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "WhiteListAdapter::VisitL PXLOGICAL visited, push support is %d" ),

            iLogicalProxyPushSupport ) );

        // iItemsToBeAdded contains physical proxies whose push support

        // is either PushEnabled or PushDontCare (i.e. PushDisabled proxies

        // are not present in this array).

        if ( iLogicalProxyPushSupport == EPushEnabled )

            {

            // Knowing that the logical proxy's push support is PushEnabled,

            // we have to add each element of the above-mentioned array.

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

                {

                // If addition fails, then we delete the item. Otherwise,

                // the ownership has been taken over by iItems array.

                if ( iItems.Append( iItemsToBeAdded[i] ) != KErrNone )

                    {

                    delete iItemsToBeAdded[i];

                    }

                }

            }

        else

            {

            // We're here : logical proxy's push support is either PushDontCare

            // or PushDisabled. In this case we have to add only those elements

            // in the array whose push support is PushEnabled. This is because

            // physical proxy's push support definition is stronger than the

            // logical proxy's definition.

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

                {

                TWhiteListAdapterItem* item = iItemsToBeAdded[i];

                if ( item->PushSupport() == EPushEnabled )

                    {

                    // If addition fails, then we delete the item. Otherwise,

                    // the ownership has been taken over by iItems array.

                    if ( iItems.Append( item ) != KErrNone )

                        {

                        delete item;

                        }

                    }

                else

                    {

                    delete item;

                    }

                }

            }

        // There is only one thing we need to do here : reset the array.

        // At this point, each element in the array is invalid : if the

        // element happened to be valid, then the other array (iItems)

        // took over the ownership. Otherwise (i.e. the element was

        // invalid), the element got deleted manually.

        // Thus, we can safely reset the array.

        iItemsToBeAdded.Reset();

		iLogicalProxyPushSupport = EPushDontCare;

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "<- WhiteListAdapter::VisitL PXLOGICAL" ) ) );

		}

	else if ( aCharacteristic.Type() == KWPPxPhysical )

		{

		// This deletion is for safety's sake : if one of the leaving methods

		// in this section (below) has left, then it may happen that this

		// method is called again and iCurrentItem is not NULL. If it is the

		// case, we can avoid having an orphaned memory area by deleting the

		// current item before allocating a new one.

		// However, in most cases iCurrentItem will be NULL.

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "-> WhiteListAdapter::VisitL PXPHYSICAL" ) ) );

        delete iCurrentItem;

		iCurrentItem = NULL;

		iCurrentItem = new (ELeave) TWhiteListAdapterItem();

		iPhysicalProxyIsVisited = ETrue;

		aCharacteristic.AcceptL( *this );

		iPhysicalProxyIsVisited = EFalse;

		if ( iCurrentItem->Valid() )

			{

			User::LeaveIfError( iItemsToBeAdded.Append( iCurrentItem ) );

            iCurrentItem = NULL; // Ownership transferred.

            CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

              _L( "WhiteListAdapter::VisitL PXPHYSICAL valid & added" ) ) );

			}

		else

			{

            CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                _L( "WhiteListAdapter::VisitL PXPHYSICAL invalid" ) ) );

			// invalid physical proxy (at least from our point of view)

			delete iCurrentItem;

            iCurrentItem = NULL;

			}

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "<- WhiteListAdapter::VisitL PXPHYSICAL" ) ) );

		}

	}

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

// CWhiteListAdapter::VisitL

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

//

void CWhiteListAdapter::VisitL( CWPParameter& aParameter )

	{

	switch ( aParameter.ID() )

		{

		case EWPParameterPhysicalProxyID :

			{

			__ASSERT_DEBUG( iCurrentItem, Panic( ENullProxy ) );

            CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                _L( "WhiteListAdapter::VisitL PhysicalProxyID" ) ) );

			if ( iCurrentItem )

				{

				iCurrentItem->SetProxyId( aParameter.Value() );

				}

			break;

			}

		case EWPParameterPxAddr :

			{

			__ASSERT_DEBUG( iCurrentItem, Panic( ENullProxy ) );

            CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                _L( "WhiteListAdapter::VisitL PxAddr" ) ) );

            if ( iCurrentItem )

				{

				iCurrentItem->SetAddress( aParameter.Value() );

				}

			break;

			}

		case EWPParameterPxAddrType :

			{

			__ASSERT_DEBUG( iCurrentItem, Panic( ENullProxy ) );

            CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                _L( "WhiteListAdapter::VisitL PxAddrType" ) ) );

			if ( iCurrentItem )

				{

				iCurrentItem->SetAddressType( aParameter.Value() );

				}

			break;

			}

		case EWPParameterPushEnabled :

			{

			if ( iCurrentItem )

				{

                CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                    _L( "WhiteListAdapter::VisitL Physical PushEnabled" ) ) );

                // it is a physical proxy

				iCurrentItem->SetPushSupport

								( ResolvePushSupport( aParameter.Value() ) );

				}

			else

				{

                CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

                    _L( "WhiteListAdapter::VisitL Logical PushEnabled" ) ) );

				// it is a logical proxy

				iLogicalProxyPushSupport =

									ResolvePushSupport( aParameter.Value() );

				}

			break;

			}

		default :

			break;

		}

	}

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

// CWhiteListAdapter::VisitLinkL

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

//

void CWhiteListAdapter::VisitLinkL( CWPCharacteristic& /*aCharacteristic*/ )

	{

	}

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

// CWhiteListAdapter::HandleSessionEventL

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

//

void CWhiteListAdapter::HandleSessionEventL( TMsvSessionEvent /*aEvent*/,

											TAny* /*aArg1*/,

											TAny* /*aArg2*/,

											TAny* /*aArg3*/ )

	{

	}

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

// CWhiteListAdapter::ResolvePushSupport

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

//

TPushSupport CWhiteListAdapter::ResolvePushSupport( const TDesC& aPushSupport )

	{

	TPushSupport support = EPushDontCare;

	if ( aPushSupport.Length() == KPushEnabledFlagLength )

		{

		if ( aPushSupport[0] == KPushEnabledFlagTrue )

			{

			support = EPushEnabled;

			}

		else if ( aPushSupport[0] == KPushEnabledFlagFalse )

			{

			support = EPushDisabled;

			}

		}

	return support;

	}

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

// CWhiteListAdapter::SaveDataL

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

//

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

	{

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter::SaveDataL %d %d %d" ), 

        iItems.Count(), aIndex, iItems[aIndex]->Id() ) );

    return ( iItems[aIndex]->IdBuf() );

	}

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

// CWhiteListAdapter::DeleteL

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

//

void CWhiteListAdapter::DeleteL( const TDesC8& aSaveData )

	{

    // Copy source into a package buffer:

    TPckgBuf<TUint32> entryIdBuf;

    entryIdBuf.Copy( aSaveData );

    // Extract the entry ID:

    TUint32 entryId( entryIdBuf() );

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter::DeleteL ID %d" ), entryId ) );

    // Now entryId holds the ID - we can remove it from WL:

    CPushInitiatorList& whiteList = iPushMtmSettings->PushInitiatorList();

    // Find the index of the Initiator with the given ID.

    TInt index( KErrNotFound );

    // As the entries are unique in WL by the ID, it's enough 

    // to continue the loop until first hit.

    const TInt count( whiteList.Count() );

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

        {

        const CPushInitiator& initiator = whiteList.At(i);

        if ( initiator.EntryID() == entryId )

            {

            index = i;

            // Found:

            break;

            }

        }

    CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

        _L( "WhiteListAdapter::DeleteL index %d" ), index ) );

    if ( index != KErrNotFound )

        {

        whiteList.Delete( index );

        // Commit changes.

        iPushMtmSettings->SaveL();

        CLOG( ( ELogBasic, WHITELISTADAPTER_LOG_LEVEL,

            _L( "WhiteListAdapter::DeleteL Saved..." ) ) );

        }

	}

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

// CWhiteListAdapter::Uid

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

//

TUint32 CWhiteListAdapter::Uid() const

	{

    return (TUint32)KWhiteListAdapterImplementationUid;

	}

// End of file