/*

* Copyright (c) 2006-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:  ?Description

*

*/

#include "musavailabilitypluginmanager.h"

#include "musavasettings.h"

#include "musunittesting.h"

#include "musavainterface.h"

#include "muslogger.h"

#include "musavailabilitypluginmanagerobserver.h"

#include "musmanagerservercommon.h"

#include "musindicatorapi.h"

#include "musapplicationmanager.h"

#include <badesca.h>

#include <bamdesca.h>

#include <e32property.h>

// CONSTANTS

using namespace MultimediaSharing;

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

//

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

//

CMusAvailabilityPluginManager* CMusAvailabilityPluginManager::NewL(

                          MMusAvailabilityPluginManagerObserver& aObserver,

                          CMusApplicationManager& aApplicationManager )

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::NewL()" )

    CMusAvailabilityPluginManager* self =

                          CMusAvailabilityPluginManager::NewLC( aObserver,

                                                                aApplicationManager );

    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::NewL()" )

    return self;

    }

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

//

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

//

CMusAvailabilityPluginManager* CMusAvailabilityPluginManager::NewLC(

                          MMusAvailabilityPluginManagerObserver& aObserver,

                          CMusApplicationManager& aApplicationManager )

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::NewLC()" )

    CMusAvailabilityPluginManager* self =

                   new( ELeave ) CMusAvailabilityPluginManager( aObserver, 

                                                                aApplicationManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::NewLC()" )

    return self;

    }

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

//

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

//

CMusAvailabilityPluginManager::~CMusAvailabilityPluginManager()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

             ~CMusAvailabilityPluginManager()" )

    delete iPlugin;

    delete iSessionParameters;

    delete iIndicator;

    iIndicator = NULL;

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

             ~CMusAvailabilityPluginManager()" )

    }

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

//

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

//

void CMusAvailabilityPluginManager::ConstructL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::ConstructL()" )

    iSessionParameters = new( ELeave ) CDesCArrayFlat( KParameterCount );

    iPlugin = CMusAvaInterface::NewL();

    iPlugin->SetObserver( *this );

   	iPlugin->SetSettingsObserver( *this );

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::ConstructL()" )

    }

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

//

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

//

CMusAvailabilityPluginManager::CMusAvailabilityPluginManager(

                          MMusAvailabilityPluginManagerObserver& aObserver,

                          CMusApplicationManager& aApplicationManager )

    : iObserver( aObserver ), 

      iApplicationManager( aApplicationManager )

    {

    iPluginStarted = EFalse;

    }

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

//

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

//

TBool CMusAvailabilityPluginManager::ApplicationAllowed()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        ApplicationAllowed()" )

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        ApplicationAllowed()" )

    return ( iPlugin->MandatoryAvailability()

        || iPlugin->AvailabilityState( EMusAvaNameRegistration ) == 

            EMusAvaStatusInProgress

        || iPlugin->AvailabilityState( EMusAvaNameRegistration ) == 

            EMusAvaStatusAvailable );

    }

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

// If minumum availability is available returning mandaroty level status

// and if mandatory level status is available returning extension level status

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

//

TMusAvailabilityStatus CMusAvailabilityPluginManager::Availability()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        Availability()" )

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        	Availability()" )

    return MapAvailabilities( iPlugin->AvailabilityStatus() );

    }

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

//

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

//

void CMusAvailabilityPluginManager::InvestigateAvailabilityL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

             InvestigateAvailabilityL()" )

    if( !iPluginStarted )

        {

        iPlugin->StartL();

        iPluginStarted = ETrue;

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

             InvestigateAvailabilityL()" )

    }

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

//

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

//

void CMusAvailabilityPluginManager::InvitationReceivedL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        InvitationReceivedL()" )

    if( !iPluginStarted )

        {

        iPlugin->StartL();

        iPluginStarted = ETrue;

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        InvitationReceivedL()" )

    }

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

// CMusAvailabilityPluginManager::OptionsReceived

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

//

void CMusAvailabilityPluginManager::OptionsReceivedL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        OptionsReceivedL()" )

    if( !iPluginStarted )

        {

        iPlugin->StartL();

        iPluginStarted = ETrue;

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        OptionsReceivedL()" )

    }

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

// CMusAvailabilityPluginManager::LoadPluginL

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

//

void CMusAvailabilityPluginManager::LoadPluginL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        LoadPluginL()" )

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        LoadPluginL()" )

    }

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

// CMusAvailabilityPluginManager::UnloadPluginL

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

//

void CMusAvailabilityPluginManager::StopPluginL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        StopPluginL()" )

    if( iPluginStarted )

        {

        iPlugin->Stop();

        iPluginStarted = EFalse;

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        StopPluginL()" )

    }

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

//

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

//

MDesCArray& CMusAvailabilityPluginManager::SessionParametersL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        SessionParametersL()" )

    // update the values

    UpdateSessionParametersL();

    // then pass them

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        SessionParametersL()" )

    return *iSessionParameters;

    }

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

//

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

//

void CMusAvailabilityPluginManager::ManualQueryL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        ManualQueryL()" )

  	MMusAvaSettings& settings = iPlugin->Settings();

    MUS_LOG( "mus: [MUSSRV]    Status available" )

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        ManualQueryL()" )  

    }

TBool CMusAvailabilityPluginManager::PossibleToLaunch()

    {

    return iPlugin->ExtensionAvailability() && 

    	iPlugin->AvailabilityStatus() == 

    		MMusAvaObserver::EMusAvaStatusAvailable;

    }

void CMusAvailabilityPluginManager::AvailabilityChanged( 

                                            TAvailabilityName /*aName*/, 

                                            TAvailabilityStatus aStatus )

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        AvailabilityChanged()" )

	TRAPD( err , iObserver.AvailabilityChangedL( MapAvailabilities( aStatus ) ) );

    if ( err )

        {

        // Not sure about what to do. Very rare situation.

        MUS_LOG1( "mus: [MUSSRV] AvailabilityChangedL() leave code: %d",err )

        }

    // Do some indicator things...

    TRAP( err, IndicateAvailabilityL() );

    if ( err )

        {

        // Not sure about what to do. Very rare situation.

        MUS_LOG1( "mus: [MUSSRV] IndicateAvailabilityL() leave code: %d",err )

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        AvailabilityChanged()" )	

    }

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

//

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

//

void CMusAvailabilityPluginManager::AvailabilityError( 

                                            TAvailabilityName /*aName*/, 

                                            TAvailabilityStatus aStatus )

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        AvailabilityError()" )

    TRAPD( err , iObserver.AvailabilityChangedL( MapAvailabilities( aStatus ) ) );

    if ( err )

        {

        // Not sure about what to do. Very rare situation.

        MUS_LOG1( "mus: [MUSSRV] AvailabilityChangedL() leave code: %d",err )

        }

    // Do some indicator things...

    TRAP( err, IndicateAvailabilityL() );

    if ( err )

        {

        MUS_LOG1( "mus: [MUSSRV] IndicateAvailabilityL() leave code: %d",err )

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        AvailabilityError()" )	

    }

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

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

//

MMusAvaSettingsObserver::TApplicationState CMusAvailabilityPluginManager::

    ApplicationState()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        ApplicationState()" )

    MMusAvaSettingsObserver::TApplicationState ret = EApplicationStateNotDefined;   

    if ( iApplicationManager.ApplicationRunning() )

        {

        ret = EApplicationIsRunning;

        }

    else

        {

        ret = EApplicationNotRunning;

        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        ApplicationState()" )

    return ret;

    }

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

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

//

TBool CMusAvailabilityPluginManager::OptionAllowed()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusAvailabilityPluginManager::\

        OptionAllowed()" )

    MUS_LOG( "mus: [MUSSRV]  <- CMusAvailabilityPluginManager::\

        OptionAllowed()" )

    // TBD: Check it out

    return iPlugin->AvailabilityState( MMusAvaObserver::EMusAvaOptionHandler )

        >= EMusAvaStatusNotExecuted;

    }

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

// From MMusIndicatorObserver.

// Starts live video sharing.

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

//

void CMusAvailabilityPluginManager::StartLiveSharingL()

    {

    }

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

// This functions cross-links TAvailabilityStatus and

// MultimediaSharing::TMusAvailabilityStatus

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

//

MultimediaSharing::TMusAvailabilityStatus

        CMusAvailabilityPluginManager::MapAvailabilities(

                            TAvailabilityStatus aStatus )

    {

    MultimediaSharing::TMusAvailabilityStatus status;

    switch( aStatus )

        {

        case EMusAvaStatusNotExecuted:

            {

            MUS_LOG( "mus: [MUSSRV]     that is \

                EMultimediaSharingNotAvailable" )

            status = EMultimediaSharingNotAvailable;

            break;

            }

        case EMusAvaFailureCode:

            {

            MUS_LOG( "mus: [MUSSRV]     that is \

                EMusAvaFailureCode" )

            status = EMultimediaFailureCode;

            break;

            }

        case EMusAvaStatusInProgress: // EMusAvaStatusRegistering:

            {

            MUS_LOG( "mus: [MUSSRV]     that is ESipRegistrationPending" )

            if ( iPlugin->CurrentAvailability() > EMusAvaNameRegistration )

                {

                // SIP registration already performed, we're available

                MUS_LOG( "mus: [MUSSRV]     that is \

                    EMultimediaSharingAvailable - a" )

                status = EMultimediaSharingAvailable;

                }

            else if ( 

                iPlugin->CurrentAvailability() == EMusAvaNameRegistration )

                {

                // SIP register pending

                MUS_LOG( "mus: [MUSSRV]     that is \

                    ESipRegistrationPending - a" )

                status = ESipRegistrationPending;

                }

            else

                {

                MUS_LOG( "mus: [MUSSRV]     that is \

                    EMultimediaSharingNotAvailable - a" )

                status = EMultimediaSharingNotAvailable;

                }

            break;

            }

        case EMusAvaStatusAvailable:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EMultimediaSharingAvailable" )

            status = EMultimediaSharingAvailable;

            break;

            }

        case EMusAvaStatusNoSipProfile:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrNoSipProfile" )

            status = EErrNoSipProfile;

            break;

            }

        case EMusAvaStatusNotRegistered:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrSipRegistration" )

            status = EErrSipRegistration;

            break;

            }

        case EMusAvaStatusNoCall:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrNoActiveCall" )

            status = EErrNoActiveCall;

            break;

            }

        case EMusAvaStatusCallOnHold:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrCallOnHold" )

            status = EErrCallOnHold;

            break;

            }

        case EMusAvaOptionNotAvailable:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrOptionAvailable" )

            status = ESipOptionsNotCapable;

            break;

            }

        case EMusAvaStatusConferenceCall:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrConferenceCall" )

            status = EErrConferenceCall;

            break;

            }

        case EMusAvaStatusOptionsSent:

            {

            MUS_LOG( "mus: [MUSSRV]     that is ESipOptionsCapable" )

            status = ESipOptionsSent;

            break;

            }

        case EMusAvaStatusOptionsNotSent:

            {

            MUS_LOG( "mus: [MUSSRV]     that is ESipOptionsNotSent" )

            status = ESipOptionsNotSent;

            break;

            }

        case EMusAvaNetworkType:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrNetwork" )

            status = EErrNetwork;

            break;

            }

        case EMusAvaRoamingError:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrRoaming" )

            status = EErrRoaming;

            break;

            }

        case EMusAvaConnectionErr:

            {

            MUS_LOG( "mus: [MUSSRV]     that is EErrConnection" )

            status = EErrConnection;

            break;

            }

        case EMusActivationError:

            {