/*

* 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:      AVController server

*

*/

// INCLUDE FILES

// System

#include <e32svr.h>

#include <f32file.h> 

// upnp stack

#include <upnpdevice.h>

// upnpframework / avcontroller api

#include "upnpavcontrollerglobals.h"

// upnpframework / internal api's

#include "upnpconnectionmonitor.h"

#include "upnpsecaccesscontroller.h"

// avcontroller server internal

#include "upnpavcontrollerserver.h"

#include "upnpavcontrollersession.h"

#include <upnpsettings.h>

#include "upnpavcontrolpoint.h"

#include "upnpavdispatcher.h"

#include "upnpdevicerepository.h"

#include "upnpavdeviceextended.h"

#include "upnpaverrorhandler.h"

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt" );

#include "upnplog.h"

// CONSTANTS

_LIT8( KMediaServer,                    "MediaServer" );

_LIT8( KUPnPRootDevice,                 "upnp:rootdevice" );

const TInt KMaxDepth = 4;

const TInt KMaxDeviceCount = 6;

const TUint myRangeCount = 3;

const TInt myRanges[ myRangeCount ] = 

    {

    0, // numbers 0-18

    18, // numbers 18-81 

    81 // numbers 81-KMaxInt

    };

const TUint8 myElementsIndex[ myRangeCount ] = 

    {

    0, 

    1, 

    CPolicyServer::ENotSupported

    };

const CPolicyServer::TPolicyElement myElements[] = 

    {

    {_INIT_SECURITY_POLICY_C3(ECapabilityNetworkServices,

        ECapabilityReadUserData, ECapabilityWriteUserData ),

        CPolicyServer::EFailClient },

    {_INIT_SECURITY_POLICY_C1(ECapabilityNetworkServices),

        CPolicyServer::EFailClient}

    };

const CPolicyServer::TPolicy myPolicy =

    {

    CPolicyServer::EAlwaysPass, //specifies all connect attempts should pass

    myRangeCount,                   

    myRanges,

    myElementsIndex,

    myElements,

    };

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

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

// CUpnpAVControllerServer::CUpnpAVControllerServer

// See upnpavcontrollerserver.h

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

CUpnpAVControllerServer::CUpnpAVControllerServer( TInt aPriority ):

    CPolicyServer( aPriority, myPolicy ),

    iShutdownTimeoutValue( KTimerCycle10 ),

    iServerState( EStateUndefined )

    {    

    }

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

// CUpnpAVControllerServer::ConstructL

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::ConstructL()

    {

    __LOG( "CUpnpAVControllerServer::ConstructL" );

    iDispatcher = CUPnPAVDispatcher::NewL( *this );

    iServerState = EStateStartingUp;

    CUpnpSettings* settings = CUpnpSettings::NewL( KCRUidUPnPStack );

    settings->Get( CUpnpSettings::KUPnPStackIapId, iIAP );

    delete settings;    

    User::LeaveIfError( iMediaServer.Connect() );

    iMonitor = CUPnPConnectionMonitor::NewL( *this, iIAP );

    StartL( KAVControllerName );   

    iServerTimer = CUPnPAVTimer::NewL( *this,

        CUPnPAVTimer::ETimerServerShutdown );

    iServerTimer->Start( iShutdownTimeoutValue );

    iMSTimer = CUPnPAVTimer::NewL( *this, CUPnPAVTimer::ETimerMediaServer );

    __LOG( "CUpnpAVControllerServer::ConstructL - Finished" );

    }

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

// CUpnpAVControllerServer::StartUpL

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::StartUpL()

    {

    __LOG( "CUpnpAVControllerServer::StartUpL" );

    TInt error = KErrNone;

    if( iServerState == EStateStartingUp )

        {

        __LOG( "StartUpL - Starting up" );

        if( !iAVControlPoint )

            {

            __LOG( "CUpnpAVControllerServer::StartUpL - CP" );

            TRAP( error, iAVControlPoint = CUpnpAVControlPoint::NewL( 

                                                               *iDispatcher ));

            // If operation fails for some reason , the 10 second timeout 

            // is completely useless and wrong in this case. 

            // The server should be shut down immediately   

            if( error != KErrNone )

                {

                iShutdownTimeoutValue = 0;   

                User::Leave( error );

                }

            }

        if( !iDeviceRepository )

            {

            iDeviceRepository = CUPnPDeviceRepository::NewL( *iAVControlPoint );

            }

        iServerState = EStateRunning;  

        }

    else if( iServerState == EStateShuttingDown )

        {

        __LOG( "StartUpL - Wlan disconnected or shutting down, leave" );

        User::Leave( KErrDisconnected );

        }

    else

        {

        __LOG( "StartUpL - Server running" );

        }        

    __LOG( "StartUpL - Completed" );    

    }

void CUpnpAVControllerServer::CancelStartUp()

    {

    __LOG( "CUpnpAVControllerServer::CancelStartUp" );

    // Cancel can occur only when the av controller instance is deleted

    // right after the asyncronous part of the construction has been

    // started. There is no proper way to cancel, but we can set the

    // shutdown timer to 0, so the server will shutdown immidiately.

    if( iSessionCount <= 1 )

        {

        iShutdownTimeoutValue = 0;    

        }  

    }

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

// CUpnpAVControllerServer::NewLC

// See upnpavcontrollerserver.h

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

CUpnpAVControllerServer* CUpnpAVControllerServer::NewLC()

    {

    CUpnpAVControllerServer* self = new( ELeave )

        CUpnpAVControllerServer( EPriorityNormal );   

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpAVControllerServer::~CUpnpAVControllerServer

// See upnpavcontrollerserver.h

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

CUpnpAVControllerServer::~CUpnpAVControllerServer()

    {

    __LOG( "CUpnpAVControllerServer::~CUpnpAVControllerServer" );

    delete iAVControlPoint;

    delete iDispatcher;

    delete iDeviceRepository;

    delete iMonitor;

    delete iServerTimer;

    delete iMSTimer;

    iMediaServer.Close();

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

        {

        iStartMessages[ i ]->Complete( KErrCancel );

        }

    iStartMessages.ResetAndDestroy();  

    }

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

// CUpnpAVControllerServer::NewSessionL

// See upnpavcontrollerserver.h

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

CSession2* CUpnpAVControllerServer::NewSessionL( const TVersion& aVersion,

    const RMessage2& aMessage ) const

    {

    __LOG( "CUpnpAVControllerServer::NewSessionL" );

    if( iServerState == EStateShuttingDown )

        {

        __LOG( "NewSessionL - server shutting down, no new sessions \

are allowed at this point" );

        User::Leave( KErrDisconnected );

        }

    else if( iServerState == EStateStartingUp && iSessionCount > 0 )

        {

        __LOG( "NewSessionL - server starting up, no new sessions \

are allowed at this point" );

        User::Leave( KErrServerBusy );

        }

    // Check we're the right version

    if ( !User::QueryVersionSupported( TVersion( 

            KAVControllerMajorVersionNumber,

            KAVControllerMinorVersionNumber,

            KAVControllerBuildVersionNumber ),

            aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    // Make new session

    RThread client;

    aMessage.Client(client);  

    return CUpnpAVControllerSession::NewL(

        *(CUpnpAVControllerServer*)this );

    }

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

// CUpnpAVControllerServer::UPnPAVTimerCallback

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::UPnPAVTimerCallback(

    CUPnPAVTimer::TAVTimerType aType ) 

    {

    __LOG( "CUpnpAVControllerServer::UPnPAVTimerCallback" );

    if( aType == CUPnPAVTimer::ETimerServerShutdown )

        {

        iServerState = EStateShuttingDown;

        if( iMSTimer->IsActive() )

            {

            // if the Media Server timer is still running for some reason

            iMSTimer->Cancel();

            StopMediaServer();

            }

        CActiveScheduler::Stop();

        }

    else if( aType == CUPnPAVTimer::ETimerMediaServer )

        {

        if( iStartingMS )

            {

            StopMediaServer();

            TInt count = iStartMessages.Count();

            for( TInt i = 0; i < count; i++ )

                {

                iStartMessages[ i ]->Complete( KErrTimedOut );

                }

            iStartMessages.ResetAndDestroy();

            iStartingMS = EFalse;

            }

        else // Shutting down

            {

            StopMediaServer();

            }            

        }

    else

        {

        }        

    }

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

// CUpnpAVControllerServer::ConnectionLost

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::ConnectionLost()

    {

    __LOG( "CUpnpAVControllerServer::ConnectionLost" );

    iShutdownTimeoutValue = 0; // Set shutdown timer value to 0, we want to

    // shut down the server immidiately after the last session has been

    // closed

    if( iServerState == EStateRunning && iDeviceRepository )

        {

        __LOG( "ConnectionLost - Server running" );

        iDeviceRepository->ConnectionLost();    

        CSession2* s;

        iSessionIter.SetToFirst(); 

        while ( ( s = iSessionIter++ ) != NULL )

            {

            CUpnpAVControllerSession* sess =

                static_cast<CUpnpAVControllerSession*>(s);

            if( sess )

                {

                sess->ConnectionLost();    

                }

            };  

        iServerState = EStateShuttingDown;

        }

    else if (iServerState == EStateStartingUp )

        {

        __LOG( "ConnectionLost - Server starting up" );

        iServerState = EStateShuttingDown;

        }    

    // If don't have any clients connect to server and current WLAN connection

    // is lost, we want to shut down the server immidiately.

    if ( iSessionCount <= 0 )

        {

        if ( iServerTimer->IsActive() )

            {

            iServerTimer->Cancel();

            }

        iServerTimer->Start( iShutdownTimeoutValue );

        }

    }

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

// CUpnpAVControllerServer::RunError

// See upnpavcontrollerserver.h

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

TInt CUpnpAVControllerServer::RunError( TInt aError )

    {

    __LOG( "CUpnpAVControllerServer::RunError" );

    if ( aError == KErrBadDescriptor )

        {

        PanicClient( Message(), EAVControllerServerBadDescriptor );

        }

    else

        {

        Message().Complete( aError );

        }

    // The leave will result in an early return from CServer::RunL(),

    // skipping the call to request another message. So do that now in order

    // to keep the server running.

    ReStart();

    // Handled the error fully

    return KErrNone;

    }

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

// CUpnpAVControllerServer::PanicClient

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::PanicClient(const RMessage2& aMessage,

    TAVControllerServerPanic aPanic)

    {

    __LOG( "CUpnpAVControllerServer::PanicClient" );

    aMessage.Panic( KAVControllerName, aPanic );

    }

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

// CUpnpAVControllerServer::PanicServer

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::PanicServer(TAVControllerServerPanic aPanic)

    {

    __LOG( "CUpnpAVControllerServer::PanicServer" );

    User::Panic( KAVControllerName, aPanic );

    }

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

// CUpnpAVControllerServer::ThreadFunctionL

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::ThreadFunctionL()

    {

    __LOG( "CUpnpAVControllerServer::ThreadFunctionL" );

    // Construct active scheduler

    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL( activeScheduler );

    // Install active scheduler

    // We don't need to check whether an active scheduler is already

    // installed

    // as this is a new thread, so there won't be one

    CActiveScheduler::Install( activeScheduler );    

    // Construct our server        

    CUpnpAVControllerServer* server = CUpnpAVControllerServer::NewLC();

    RProcess::Rendezvous( KErrNone );                

    // Start handling requests

    CActiveScheduler::Start();      

    CleanupStack::PopAndDestroy( server );  

    CleanupStack::PopAndDestroy( activeScheduler );

    }

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

// CUpnpAVControllerServer::HandleEmbeddedDiscoveredDevicesL

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::HandleEmbeddedDiscoveredDevicesL(

    CUpnpDevice& aDevice, TInt aDepth )

    {

    __LOG( "CUpnpAVControllerServer::HandleEmbeddedDiscoveredDevicesL" );

    if( aDepth <= KMaxDepth && iDiscoveredDeviceCount <= KMaxDeviceCount )

        {

        RPointerArray<CUpnpDevice>& devList = aDevice.DeviceList();

        TInt count = devList.Count();

        for( TInt i = 0; i < count; i++ )

            {

            iDeviceRepository->AddDeviceL( *devList[ i ] );

            TInt sessionId = iAVControlPoint->CmProtocolInfoActionL(

                devList[ i ]->Uuid() );

            iDiscoveredDeviceCount++;    

            HandleEmbeddedDiscoveredDevicesL( *devList[ i ], ++aDepth );

            }        

        }

    else

        {

        __LOG( "HandleEmbeddedDiscoveredDevicesL - max depth \

or count reached" );

        }    

    }

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

// CUpnpAVControllerServer::HandleEmbeddedDisappearedDevicesL

// See upnpavcontrollerserver.h

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

void CUpnpAVControllerServer::HandleEmbeddedDisappearedDevicesL(

    CUpnpDevice& aDevice, TInt aDepth )

    {

    __LOG( "CUpnpAVControllerServer::HandleEmbeddedDisappearedDevicesL" );

    if( aDepth <= KMaxDepth && iDisappearedDeviceCount <= KMaxDeviceCount )

        {

        RPointerArray<CUpnpDevice>& devList = aDevice.DeviceList();

        TInt count = devList.Count();

        for( TInt i = 0; i < count; i++ )

            {

            CUpnpAVDeviceExtended& ext = iDeviceRepository->FindDeviceL(

                devList[ i ]->Uuid() );

            CSession2* s;

            iSessionIter.SetToFirst(); 

            while ( ( s = iSessionIter++ ) != NULL )

                {

                CUpnpAVControllerSession* sess =

                    static_cast<CUpnpAVControllerSession*>(s);

                if( sess )

                    {

                    sess->DeviceDisappearedL( ext );    

                    }

                };        

            iDeviceRepository->Remove( ext.Uuid() );

            iDisappearedDeviceCount++;    

            HandleEmbeddedDisappearedDevicesL( *devList[ i ], ++aDepth );

            }        

        }

    else

        {

        __LOG( "HandleEmbeddedDisappearedDevicesL - max depth \

or count reached" );

        }    

    }