/*

* 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:  Stub class of CMusAvaInterface to support unit testing.

*

*/

#include "cmusavainterfacestub.h"

#include "musavaavailabilitystub.h"

#include "mmusavasettingsstub.h"

#include "musavaavailability.h"

#include "musavaavailabilityobserverimp.h"

const MMusAvaObserver::TAvailabilityName KMinimumAvailability

    = MMusAvaObserver::EMusAvaBearerStatus;

const MMusAvaObserver::TAvailabilityName KMandatoryAvailability

    = MMusAvaObserver::EMusAvaNameRegistration;

const MMusAvaObserver::TAvailabilityName KExtensionAvailability

    = MMusAvaObserver::EMusAvaOptionHandler;

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

CMusAvaInterface2* CMusAvaInterface2::NewL()

	    {

	    CMusAvaInterface2* self = new( ELeave ) CMusAvaInterface2();

	    CleanupStack::PushL( self );

	    self->ConstructL();

	    CleanupStack::Pop( self );

	    return self;

	    }

CMusAvaInterface2::~CMusAvaInterface2()

	    {

	    iAvailabilities.ResetAndDestroy();

	    iAvailabilities.Close();

	    delete iSettings;

	    delete iMusAvailObs;

	    }

CMusAvaInterface2::CMusAvaInterface2()

    {

    }

void CMusAvaInterface2::ConstructL()

    {

    iSettings = new(ELeave)CMusAvaSettings2();

    iSettings->ConstructL();

    // Create network availability stub

    iMusAvailObs = CMusAvaAvailabilityObserverImp::NewL();

    CMusAvaAvailabilityStub* stub = CMusAvaAvailabilityStub::NewLC( *iMusAvailObs, *iSettings );

    iAvailabilities.AppendL( stub );

    CleanupStack::Pop( stub );

    }

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

// Requests the implementation to provide availabilites.

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

//

void CMusAvaInterface2::Availability()

    {

    }

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

// Called by the ECOM framework when MusAvailability Plug-in is request

// retuns setting interface for the client.

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

//

MMusAvaSettings& CMusAvaInterface2::Settings()

    {

    return *iSettings;

    }

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

// Called by the ECOM framework when MusAvailability Plug-in is for

// setting Observer interface for the client.

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

//

void CMusAvaInterface2::SetObserver( MMusAvaObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// Called by the ECOM framework when MusAvailability Plug-in is request

// to investigate availabilites for the client.

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

//

void CMusAvaInterface2::StartL()

    {

    }

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

// Called by the ECOM framework when MusAvailability Plug-in is request

// to stop investigate or monitoring availabilites for the client.

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

//

void CMusAvaInterface2::Stop()

    {

    }

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

//  tbd

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

//

MMusAvaObserver::TAvailabilityName CMusAvaInterface2::CurrentAvailability()

    {

    return iCurrentAvailability;

    }

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

//  tbd

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

//

MMusAvaObserver::TAvailabilityStatus CMusAvaInterface2::AvailabilityStatus()

    {

    return iAvailabilityStatus;

    }

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

//  tbd

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

//

TBool CMusAvaInterface2::MinimumAvailability()

    {

    return iCurrentAvailability > KMinimumAvailability;

    }

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

//  tbd

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

//

TBool CMusAvaInterface2::MandatoryAvailability()

    {

    return iCurrentAvailability > KMandatoryAvailability;

    }

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

//  tbd

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

//

TBool CMusAvaInterface2::ExtensionAvailability()

    {

    return iCurrentAvailability > KExtensionAvailability;

    }

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

//  tbd

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

//

TBool CMusAvaInterface2::Available(

    MMusAvaObserver::TAvailabilityName aAvailability )

    {

    return iCurrentAvailability > aAvailability

           || ( iCurrentAvailability == aAvailability

           && MMusAvaObserver::EMusAvaStatusAvailable == iAvailabilityStatus );

    }

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

//  tbd

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

//

MMusAvaObserver::TAvailabilityStatus CMusAvaInterface2::AvailabilityState(

    MMusAvaObserver::TAvailabilityName aAvailability )

    {

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

        {

        if ( iAvailabilities[i]->Name() == aAvailability )

            {

            return iAvailabilities[i]->State();

            }

        }

    return MMusAvaObserver::EMusAvaStatusNotExecuted;

    }

void CMusAvaInterface2::AvailabilityChanged(

        TAvailabilityName aName,

        TAvailabilityStatus aStatus )

	{

	}

void CMusAvaInterface2::AvailabilityError(

        TAvailabilityName aName,

        TAvailabilityStatus aStatus )

	{

	}

void CMusAvaInterface2::SetSettingsObserver( MMusAvaSettingsObserver& aObserver )

    {

    }

// ======== GLOBAL FUNCTIONS ========

CImplementationInformation::CImplementationInformation()

    {

    }

CImplementationInformation::~CImplementationInformation()

    {

    }

CImplementationInformation* CImplementationInformation::NewL(

    {

    }

void REComSession::DestroyedImplementation( TUid )

    {

    }

void REComSession::ListImplementationsL(

    TUid /*aInterfaceUid*/,

    RImplInfoPtrArray &aImplInfoArray )

    {

    TUid uid = { 0x10101010 };

    TDriveUnit drive;

    HBufC* name( NULL );

    HBufC8* type( NULL );

    CImplementationInformation* info = 

        CImplementationInformation::NewL( uid,

                                          1,

                                          name,

                                          type,

                                          type,

                                          drive,

                                          EFalse,

                                          EFalse );

    CleanupStack::PushL( info );

    aImplInfoArray.AppendL( info );

    CleanupStack::Pop( info );

    }

TAny* REComSession::CreateImplementationL(

    TUid /*aImplementationUid*/,

    TInt32 /*aDtorIDKey*/ )

    {

    return CMusAvaInterface2::NewL();

    }