/*
* Copyright (c) 2006 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 "musunittesting.h"

#include "musmanagerservercore.h"
#include "musapplicationmanager.h"
#include "musavailabilitypluginmanager.h"
#include "musmonitoravailabilityobserver.h"
#include "muslogger.h"
#include "musmanagerservercoreobserver.h"
#include "musmanager.h"
#include "musmanagerservercommon.h"

using namespace MultimediaSharing;

// CONSTANTS
_LIT8( KMusEngineName, "MultimediaSharing" );


// -----------------------------------------------------------------------------
// CMusManagerServerCore::NewL
// -----------------------------------------------------------------------------
//
CMusManagerServerCore* CMusManagerServerCore::NewL(
    MMusManagerServerCoreObserver& aObserver )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::NewL()" );

    CMusManagerServerCore* self = CMusManagerServerCore::NewLC( aObserver );
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::NewL()" );
    return self;
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::NewLC
// -----------------------------------------------------------------------------
//
CMusManagerServerCore* CMusManagerServerCore::NewLC(
    MMusManagerServerCoreObserver& aObserver )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::NewLC()" );

    CMusManagerServerCore* self
        = new( ELeave ) CMusManagerServerCore( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::NewLC()" );
    return self;
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::CMusManagerServerCore
// -----------------------------------------------------------------------------
//
CMusManagerServerCore::CMusManagerServerCore( MMusManagerServerCoreObserver& aObserver )
    : iObserver( aObserver )
    {
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::ConstructL
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::ConstructL()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::ConstructL" );
    
    iApplicationManager = CMusApplicationManager::NewL();
    
    iApplicationManager->ResolvePluginNameL( iPluginName );
    
    iPluginManager = CMusAvailabilityPluginManager::NewL( *this, *iApplicationManager );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::ConstructL" );
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::~CMusManagerServerCore
// -----------------------------------------------------------------------------
//
CMusManagerServerCore::~CMusManagerServerCore()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::CMusManagerServerCore" );

     // inform ui via application manager (via session api)
    
    delete iPluginManager;

    delete iApplicationManager;
    
     // go through interested client sessions
    StopMonitoring();
    iAvailabilityMonitors.Close();
    
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::CMusManagerServerCore" );
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::~CMusManagerServerCore
// -----------------------------------------------------------------------------
//
MultimediaSharing::TMusAvailabilityStatus CMusManagerServerCore::AvailabilityQueryL()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::AvailabilityQueryL" );
    MultimediaSharing::TMusAvailabilityStatus status
            = Availability();
   
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::AvailabilityQueryL" );
    return status;
    }
 // -----------------------------------------------------------------------------
// CMusManagerServerCore::InvestigateAvailability
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::CommandL( MultimediaSharing::TCommandType aCommandType )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::CommandL" );
     if ( aCommandType == MultimediaSharing::ECommandManualActivation &&
          IsMusEnginePlugin() )
		{
		MUS_LOG( "mus: [MUSSRV]    Manual Activation is started" )
		iPluginManager->ManualQueryL();
		}
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::CommandL" );
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::InvestigateAvailability
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::InvestigateAvailabilityL()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::InvestigateAvailabilityL" );
    if ( IsMusEnginePlugin() )
        {
        iPluginManager->InvestigateAvailabilityL();
        }
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::InvestigateAvailabilityL" );
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::InvitationReceived
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::InvitationReceivedL( TUid aChannelId )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::InvitationReceivedL" );

    TInt uid = aChannelId.iUid;

    if( uid == CMusManager::ESipInviteDesired &&
        ApplicationAllowed() )
        {        
        PrepareForReceivedInviteL();
        
        // write session boundary values
        WriteSessionPropertiesL(
                MultimediaSharing::EMusReceive,
                Availability(),
                iPluginManager->SessionParametersL() );

        iApplicationManager->StartApplicationL();
        }
    else if( uid == CMusManager::ESipInviteDesired2WayVideo &&
            ApplicationAllowed() )
        {
        PrepareForReceivedInviteL();
        
        // write session boundary values
        WriteSessionPropertiesL(
                MultimediaSharing::EMusReceiveTwoWayVideo,
                Availability(),
                iPluginManager->SessionParametersL() );

        iApplicationManager->StartApplicationL();
        }
    else if ( IsMusEnginePlugin() )
        {
        if( uid == CMusManager::ESipInviteNotDesired )
            {
            iPluginManager->InvitationReceivedL();
            }
        else
            {
            User::Leave( KErrNotReady );
            }
        }

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::InvitationReceivedL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::OptionsReceivedL( TUid /*aChannelId*/ )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::OptionsReceivedL" );
    if ( IsMusEnginePlugin() )
        {
        iPluginManager->OptionsReceivedL();    
        }    
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::OptionsReceivedL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::StartMultimediaSharingL( MultimediaSharing::TMusUseCase aUseCase )
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::StartMultimediaSharingL" );
    if( !iApplicationManager->ApplicationRunning() &&
        ApplicationAllowed() )
        {
        // write session boundary values
        WriteSessionPropertiesL(
                aUseCase,
                Availability(),
                iPluginManager->SessionParametersL() );

        // start actual application
        iApplicationManager->StartApplicationL();
        }
    else
        {
        iApplicationManager->ShowApplicationL();
        }
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::StartMultimediaSharingL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::StopMultimediaSharingL()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::StopMultimediaSharingL" );
    iApplicationManager->StopApplicationL();
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::StopMultimediaSharingL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::EventNoSessions()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::EventNoSessions" );
    if ( IsMusEnginePlugin() ) 
        {
        TRAPD( error, iPluginManager->StopPluginL() );
        if( error )
            {
            // iObserver.StopServer();
            }        
        }
    iObserver.StopServer();
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::EventNoSessions" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::PluginStopped()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::PluginStopped" );
    if( iObserver.SessionCount() == 0 )
        {
        iObserver.StopServer();
        }
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::PluginStopped" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::AvailabilityChangedL(
    MultimediaSharing::TMusAvailabilityStatus aAvailability )
    {
    MUS_LOG1( "mus: [MUSSRV]  -> CMusManagerServerCore::AvailabilityChangedL( %d )",
              aAvailability );
    
    if ( !IsMusEnginePlugin() )
        {
        MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::AvailabilityChangedL - \
                non-MuS plugin");
        return;
        }
    // inform ui via application manager (via session api)

    WriteSessionPropertiesL(
            aAvailability,
            iPluginManager->SessionParametersL() );
    
    if( iAvailabilityMonitors.Count() )
    	{	
    	// go through interested client sessions
	    for( TInt i=0; i<iAvailabilityMonitors.Count(); i++ )
	        {
	        // and inform each about the new status
	       	iAvailabilityMonitors[i]->AvailabilityChangedL( 
	       		aAvailability );
	        }
    	}
    
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::AvailabilityChangedL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::CancelMonitoring( MMusMonitorAvailabilityObserver* aObserver )
	{
	TInt index = iAvailabilityMonitors.Find( aObserver );
		
	if( index != KErrNotFound )
		{
		iAvailabilityMonitors[index]->RequestComplete();
		iAvailabilityMonitors.Remove( index );
		}	
	}


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::RegisterObserverL( 
									MMusMonitorAvailabilityObserver* aObserver )
	{
    if( iAvailabilityMonitors.Find( aObserver ) == KErrNotFound )
		{
		iAvailabilityMonitors.AppendL( aObserver );
		}
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::RegisterObserver" );	
	}

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//	
void CMusManagerServerCore::RemoveObserver( MMusMonitorAvailabilityObserver* aObserver )
	{
	MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::RemoveObserver" );
    TInt index = iAvailabilityMonitors.Find( aObserver );
		
	if( index != KErrNotFound )
		{
		iAvailabilityMonitors.Remove( index );
		}
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::RemoveObserver" );	
	}

// -----------------------------------------------------------------------------
// From MMusAvailabilityPluginManagerObserver.
// Starts live video sharing.
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::StartSharingWithUseCaseL( 
    MultimediaSharing::TMusUseCase aUseCase )
    {
    MUS_LOG1( "mus: [MUSSRV]  -> CMusManagerServerCore::StartSharingWithUseCaseL:%d", 
              aUseCase );
    
    StartMultimediaSharingL( aUseCase );
    
    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::StartSharingWithUseCaseL" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::StopMonitoring()
	{
	// go through interested client sessions
    for( TInt i=0; i<iAvailabilityMonitors.Count(); i++ )
        {
        // and inform each about the new status
       	iAvailabilityMonitors[i]->RequestComplete();
       	iAvailabilityMonitors.Remove( i );
        }			
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::IsMusEnginePlugin
// -----------------------------------------------------------------------------
//
TBool CMusManagerServerCore::IsMusEnginePlugin()
    {
    TBool isMus( EFalse );    
    if ( !iPluginName.Compare( KMusEngineName ) )
        {
        isMus = ETrue;
        }
    return isMus;
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::Availability
// -----------------------------------------------------------------------------
//
MultimediaSharing::TMusAvailabilityStatus CMusManagerServerCore::Availability()
    {
    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServerCore::Availability" );
    if ( IsMusEnginePlugin() ) 
        {
        MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::Availability - MuS plugin" );
        return iPluginManager->Availability();
        }
    else
        {
        MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServerCore::Availability - non-MuS plugin" );
        return EMultimediaSharingAvailable;
        }
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::ApplicationAllowed
// -----------------------------------------------------------------------------
//
TBool CMusManagerServerCore::ApplicationAllowed()
    {
    if ( IsMusEnginePlugin() )
        {
        return iPluginManager->ApplicationAllowed();
        }
    else
        {
        return ETrue;
        }
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::PrepareForReceivedInviteL
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::PrepareForReceivedInviteL()
    {
    if ( IsMusEnginePlugin() )
        {
        iPluginManager->PrepareForReceivedInviteL();
        }
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::WriteSessionPropertiesL
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::WriteSessionPropertiesL(
        MultimediaSharing::TMusUseCase aUseCase,
        MultimediaSharing::TMusAvailabilityStatus aStatus,
        MDesCArray& aSessionParameters )
    {
    if ( IsMusEnginePlugin() )
        {
        iApplicationManager->WriteSessionPropertiesL(
                                    aUseCase,
                                    aStatus,
                                    aSessionParameters );
        }
    }

// -----------------------------------------------------------------------------
// CMusManagerServerCore::WriteSessionPropertiesL
// -----------------------------------------------------------------------------
//
void CMusManagerServerCore::WriteSessionPropertiesL(
        MultimediaSharing::TMusAvailabilityStatus aStatus,
        MDesCArray& aSessionParameters )
    {
    if ( IsMusEnginePlugin() )
        {
        iApplicationManager->WriteSessionPropertiesL(
                                    aStatus,
                                    aSessionParameters );
        }
    }

//  End of File