/*

* Copyright (c) 2006-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:  DUN USB configuration accessor and listener

*

*/

#include "DunUsbConfig.h"

#include "DunDebug.h"

const TUint KDunUsbSupportedConfigVersion = 1;

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

// Two-phased constructor.

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

//

CDunUsbConfig* CDunUsbConfig::NewL( MDunServerCallback* aServer,

                                    MDunUsbConfig* aCallback,

                                    TUint8 aProtocol )

    {

    CDunUsbConfig* self = new (ELeave) CDunUsbConfig( aServer,

                                                      aCallback,

                                                      aProtocol );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDunUsbConfig::~CDunUsbConfig()

    {

    FTRACE(FPrint( _L("CDunUsbConfig::~CDunUsbConfig()" )));

    ResetData();

    FTRACE(FPrint( _L("CDunUsbConfig::~CDunUsbConfig() complete" )));

    }

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

// Resets data to initial values

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

//

void CDunUsbConfig::ResetData()

    {

    // APIs affecting this:

    // IssueRequest()

    Stop();

    // NewL()

    iAcmProperty.Close();

    // Internal

    Initialize();

    }

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

// Compares initialized protocol number to configuration by index

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

//

TInt CDunUsbConfig::GetConfigValidityByIndex( TInt aIndex, TBool& aValidity )

    {

    FTRACE(FPrint( _L("CDunUsbConfig::GetConfigValidityByIndex()" )));

    if ( iConfigState != EUsbConfigStateIdle )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::GetConfigValidityByIndex() (not ready) complete" )));

        return KErrNotReady;

        }

    if ( !iConfigExist )

        {

        TInt retTemp = GetConfiguration( iConfig );

        if ( retTemp != KErrNone )

            {

            FTRACE(FPrint( _L("CDunUsbConfig::GetConfigValidityByIndex() (get failed) complete" )));

            return retTemp;

            }

        }

    if ( aIndex < 0 ||

         aIndex >= iConfig.iAcmCount ||

         aIndex >= TPublishedAcmConfigs::KAcmMaxFunctions )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::GetConfigValidityByIndex() (not found) complete" )));

        return KErrNotFound;

        }

    if ( iConfig.iAcmConfig[aIndex].iProtocol == iProtocol )

        {

        aValidity = ETrue;

        }

    else

        {

        aValidity = EFalse;

        }

    FTRACE(FPrint( _L("CDunUsbConfig::GetConfigValidityByIndex() complete (%d/%d)" ), aIndex, aValidity));

    return KErrNone;

    }

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

// Starts listening for ACM configuration changes

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

//

TInt CDunUsbConfig::IssueRequest()

    {

    FTRACE(FPrint( _L("CDunUsbConfig::IssueRequest()" )));

    if ( iConfigState != EUsbConfigStateIdle )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::IssueRequest() (not ready) complete" )));

        return KErrNotReady;

        }

    iStatus = KRequestPending;

    iAcmProperty.Subscribe( iStatus );

    SetActive();

    iConfigState = EUsbConfigStateWaiting;

    FTRACE(FPrint( _L("CDunUsbConfig::IssueRequest() complete" )));

    return KErrNone;

    }

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

// Stops listening for ACM configuration changes

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

//

TInt CDunUsbConfig::Stop()

    {

    FTRACE(FPrint( _L("CDunUsbConfig::Stop()" )));

    if ( iConfigState != EUsbConfigStateWaiting )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::Stop() (not ready) complete" )));

        return KErrNotReady;

        }

    iAcmProperty.Cancel();

    Cancel();

    iConfigState = EUsbConfigStateIdle;

    FTRACE(FPrint( _L("CDunUsbConfig::Stop() complete" )));

    return KErrNone;

    }

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

// CDunUsbConfig::CDunUsbConfig

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

//

CDunUsbConfig::CDunUsbConfig( MDunServerCallback* aServer,

                              MDunUsbConfig* aCallback,

                              TUint8 aProtocol ) :

    CActive( EPriorityStandard ),

    iServer( aServer ),

    iCallback( aCallback ),

    iProtocol( aProtocol )

    {

    Initialize();

    }

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

// CDunUsbConfig::ConstructL

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

//

void CDunUsbConfig::ConstructL()

    {

    FTRACE(FPrint( _L("CDunUsbConfig::ConstructL()" )));

    if ( !iServer || !iCallback )

        {

        User::Leave( KErrGeneral );

        }

    User::LeaveIfError( iAcmProperty.Attach(KUidSystemCategory,KAcmKey) );

    CActiveScheduler::Add( this );

    FTRACE(FPrint( _L("CDunUsbConfig::ConstructL() complete" )));

    }

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

// Initializes this class

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

//

void CDunUsbConfig::Initialize()

    {

    // Don't initialize iCallback here (it is set through NewL)

    // Don't initialize iProtocol here (it is set through NewL)

    iConfigState = EUsbConfigStateIdle;

    iConfig.iAcmConfigVersion = 0;

    iConfig.iAcmCount = 0;

    iConfigExist = EFalse;

    }

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

// Gets current ACM configuration

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

//

TInt CDunUsbConfig::GetConfiguration( TPublishedAcmConfigs& aConfig )

    {

    FTRACE(FPrint( _L("CDunUsbConfig::GetConfiguration()" )));

    TPckgBuf<TPublishedAcmConfigs> configBuf;

    TInt retTemp = iAcmProperty.Get( configBuf );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::GetConfiguration() (ERROR) complete" )));

        return retTemp;

        }

    aConfig = configBuf();

    // Check that version is that which we currently support

    if ( aConfig.iAcmConfigVersion != KDunUsbSupportedConfigVersion )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::GetConfiguration() (not supported) complete" )));

        return KErrNotSupported;

        }

    // Check that count is within bounds

    if ( aConfig.iAcmCount > TPublishedAcmConfigs::KAcmMaxFunctions )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::GetConfiguration() (overflow) complete" )));

        return KErrOverflow;

        }

    iConfigExist = ETrue;

    FTRACE(FPrint( _L("CDunUsbConfig::GetConfiguration() complete" )));

    return KErrNone;

    }

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

// From class CActive.

// Gets called when ACM configuration changes

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

//

void CDunUsbConfig::RunL()

    {

    FTRACE(FPrint( _L("CDunUsbConfig::RunL()" )));

    iConfigState = EUsbConfigStateIdle;

    TPublishedAcmConfigs newConfig;

    TInt retTemp = GetConfiguration( newConfig );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::RunL() (ERROR) complete (%d)" ), retTemp));

        iServer->NotifyPluginCloseRequest( KDunUsbPluginUid, ETrue );

        return;

        }

    // Change that is same is not possible so check that first

    if ( newConfig.iAcmCount == iConfig.iAcmCount )

        {

        FTRACE(FPrint( _L("CDunUsbConfig::RunL() (no change) complete" )));

        iServer->NotifyPluginCloseRequest( KDunUsbPluginUid, ETrue );

        return;

        }

    // Now we have the changed configuration so find out are there added or

    // removed USB ACMs

    TInt i;

    if ( newConfig.iAcmCount > iConfig.iAcmCount )  // addition

        {

        // Addition is always done to end of ACM queue by N entry addition

        // Scan through new array and report change if necessary

        for ( i=iConfig.iAcmCount; i<newConfig.iAcmCount; i++ )

            {

            if ( newConfig.iAcmConfig[i].iProtocol == iProtocol )

                {

                iCallback->NotifyConfigAddition( i );

                }

            }

        }

    else  // removal ( newConfig.iAcmCount < iConfig.iAcmCount )

        {

        // Removal is always done to end of ACM queue by N entry removal

        // Scan through old array and report change if necessary

        for ( i=newConfig.iAcmCount; i<iConfig.iAcmCount; i++ )

            {

            if ( iConfig.iAcmConfig[i].iProtocol == iProtocol )

                {

                iCallback->NotifyConfigRemoval( i );

                }

            }

        }

    // Update config and restart listening

    iConfig = newConfig;

    IssueRequest();

    FTRACE(FPrint( _L("CDunUsbConfig::RunL() complete" )));

    }

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

// From class CActive.

// Gets called on cancel

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

//

void CDunUsbConfig::DoCancel()

    {

    }