/*

* 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::PrepareForReceivedInviteL()

    {

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

       {

       iAvailabilities[i]->PrepareForReceivedInviteL();

       }

    }

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()

    {

    delete iData;

    delete iDisplayName;

    delete iOpaqueData;

    }

CImplementationInformation* CImplementationInformation::NewL(

    TUid	aUid,

	TInt	aVersion,

	HBufC*  aName,

	HBufC8* aDataType,

	HBufC8* aOpaqueData,

	TDriveUnit aDrive,

	TBool aRomOnly,

	TBool aRomBased)

    {

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

    CleanupStack::PushL(self);

    self->iData = aDataType;

    self->iDisplayName = aName;

    self->iOpaqueData = aOpaqueData;

    CleanupStack::Pop(self);

    return self;

    //return new (ELeave) CImplementationInformation();

    }

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();

    }

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

// REComSession::ListImplementationsL

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

//

void REComSession::ListImplementationsL(

                            TUid aInterfaceUid,

                            const TEComResolverParams& resolverParams,

                            RImplInfoPtrArray& aImplInfoArray)

    {

    _LIT8(KDefaultEngineName,"MultimediaSharing");

    TUid uid(aInterfaceUid); 

    TInt version = 1; 

    HBufC*  name = _L("dummy").AllocLC();

    HBufC8* dataType = _L8("MultimediaSharing").AllocLC();

    HBufC8* opaqueData = _L8("dummy").AllocLC();

    TDriveUnit drive;

    TBool romOnly(ETrue);

    TBool romBased(ETrue);

    CImplementationInformation* info = 

                    CImplementationInformation::NewL(uid,version,name,dataType,

                                    opaqueData,drive,romOnly,romBased);

    CleanupStack::Pop(3);

    CleanupStack::PushL(info);

    aImplInfoArray.AppendL(info);

    CleanupStack::Pop(info);

    }

// End of File