/*

* 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:      Server core

*

*/

#include    <e32base.h>

#include    "mdhserver.h"

#include    "mdhcommon.h"

#include    "mdhserversession.h"

#include    "mdhmediaservercontainer.h"

#include    "msdebug.h"

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

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

// CCmMdhServer::CCmMdhServer

// constructor

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

//

CCmMdhServer::CCmMdhServer()

    : CPolicyServer( CActive::EPriorityHigh, KCmMdhServerPolicy )

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::CCmMdhServer"));

    iServerState = ECmMdhServerStateIdle;

    }

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

// CCmMdhServer::ConstructL

// 2nd phase constructor

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

//

void CCmMdhServer::ConstructL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::ConstructL"));

    iSessionCount = 0;

    StartL( KCmMdhServerName );

    LOG(_L("[CmMdh Server]\t CCmMdhServer::ConstructL end"));

    }

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

// CCmMdhServer::NewLC

// (other items were commented in a header).

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

//

CCmMdhServer* CCmMdhServer::NewLC()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::NewLC"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCmMdhServer::~CCmMdhServer

// destructor

// (other items were commented in a header).

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

//

CCmMdhServer::~CCmMdhServer()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::~CCmMdhServer"));

    delete iMediaserverContainer;

    LOG(_L("[CmMdh Server]\t CCmMdhServer::~CCmMdhServer end"));

    }

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

// CCmMdhServer::

// 

// (other items were commented in a header).

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

//

void CCmMdhServer::CreateMediaserverContainerL()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::CreateMediaserverContainerL"));

    if ( !iMediaserverContainer )

        {

        iMediaserverContainer = 

            CCmMdhMediaserverContainer::NewL( *this );

        LOG(_L("[CmMdh Server]\t MediaserverContainer created"));

        }

    }

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

// CCmMdhServer::DestroyMediaserverContainer

// 

// (other items were commented in a header).

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

//

void CCmMdhServer::DestroyMediaserverContainer() 

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::DestroyMediaserverContainer"));

    if ( iMediaserverContainer )

        {

        delete iMediaserverContainer; iMediaserverContainer = NULL;

        LOG(_L("[CmMdh Server]\t MediaserverContainer destroyed"));

        }

    }

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

// CCmMdhServer::MediaserverContainer

// 

// (other items were commented in a header).

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

//

CCmMdhMediaserverContainer& CCmMdhServer::MediaserverContainer() 

    {

    return *iMediaserverContainer;

    }

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

// CCmMdhServer::NewSessionL

// Creates a new session to the server if version information is correct.

// (other items were commented in a header).

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

//

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

                                      const RMessage2 &/*aMessage*/) const

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::NewSessionL"));

#ifdef _DEBUG

    TInt alloc;

    TInt cells = User::Heap().AllocSize( alloc );

    TInt size = User::Heap().Size();

    TRACE( Print(

        _L("[CmMdh Server]\t NewSessionL allocsize %d, size %d, cells %d"), 

        alloc, 

        size, 

        cells ) );

#endif

    // check we're the right version

    TVersion version( KCmMdhServerMajor, 

                      KCmMdhServerMinor, 

                      KCmMdhServerBuild);

    if( !User::QueryVersionSupported( version, aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    // make new session

    return CCmMdhSession::NewL( iMediaserverContainer, 

        *const_cast<CCmMdhServer*>(this) );

    }

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

// CCmMdhServer::SetServerStateL

// 

// (other items were commented in a header).

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

//

void CCmMdhServer::SetServerStateL( TCmMdhServerState aServerState, 

                                     TInt aErrCode /* = KErrNone */)

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::SetServerState"));

    TRACE( Print( _L("[CmMdh Server]\t Setting server state from %d to %d"), 

               iServerState, aServerState));

    if ( iServerState == aServerState ) 

        {

        return;

        }

    TBool validTransition = EFalse;

    switch ( iServerState )

        {

        case ECmMdhServerStateIdle:

            if ( aServerState ) // search or harvest started

                {

                validTransition = ETrue;

                }

            break;

        case ECmMdhServerStateSearching:

            if ( aServerState == ECmMdhServerStateIdle ) // search complete

                {

                if ( aErrCode )

                    {

                    //DestroyMediaserverContainer();

                    }

                iCurrentAsyncMsg.Complete( aErrCode );

                validTransition = ETrue;    

                }

            break;

        case ECmMdhServerStateHarvesting:

            if ( aServerState == ECmMdhServerStateIdle ) // harvest complete

                {

                //DestroyMediaserverContainer();

                LOG(_L("[CmMdh Server]\t Completing..."));

                iCurrentAsyncMsg.Complete( aErrCode );

                LOG(_L("[CmMdh Server]\t Completed..."));

                validTransition = ETrue;

                if ( iSessionCount <= 0)

                    {

                    // shutdown server 

                    LOG(_L("[CmMdh Server]\t Harvest complete, \

                        shutting down.."));

                    CActiveScheduler::Stop();

                    }

                }

            break;

         default:

            // nothing

            break;

        }

    if (validTransition) 

        {

        iServerState = aServerState;   

        }

    else

        {

        User::Leave( KErrNotReady );

        }

    }

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

// CCmMdhServer::DecrementSessions

// 

// (other items were commented in a header).

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

//

void CCmMdhServer::DecrementSessions()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::DecrementSessions"));

    if ( --( iSessionCount) <= 0 

      && iServerState!= ECmMdhServerStateHarvesting ) 

      {

      LOG(_L("[CmMdh Server]\t Destroying media server container..."));

      DestroyMediaserverContainer();

      // shutdown server

      LOG(_L("[CmMdh Server]\t No sessions left, shutting down.."));

      CActiveScheduler::Stop();

      }

#ifdef _DEBUG

    TInt alloc;

    TInt cells = User::Heap().AllocSize( alloc );

    TInt size = User::Heap().Size();

    TRACE( Print(

        _L(

        "[CmMdh Server]\t DecrementSessions allocsize %d, size %d, cells %d"

          ),

        alloc, 

        size, 

        cells )); 

#endif      

    }

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

// CCmMdhServer::IncrementSessions

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

void CCmMdhServer::IncrementSessions() 

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::IncrementSessions"))

    ++iSessionCount;    

    }

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

// CCmMdhServer::ServerState

// 

// (other items were commented in a header).

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

//

TCmMdhServerState CCmMdhServer::ServerState()

    {

    LOG(_L("[CmMdh Server]\t CCmMdhServer::ServerState"));

    return iServerState;

    }

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

// CCmMdhServer::SetCurrentAsyncMsg

// 

// (other items were commented in a header).

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

//

void CCmMdhServer::SetCurrentAsyncMsg( const RMessage2& aMessage )

    {

    LOG(_L("[CmMdh Server]\t CCmServer::SetCurrentAsyncMsg"));

    iCurrentAsyncMsg = aMessage;

    }

// ========================== OTHER EXPORTED FUNCTIONS =======================

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

// PanicServer

// Server panic handler

// Panic our own thread

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

//

void PanicServer(TInt aPanic)

    {

    TRACE(Print(_L("[CmMdh Server]\t PanicServer: Reason = %d\n"), aPanic));

    User::Panic( KCmMdhServerPanic, aPanic );

    }

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

// PanicClient

// Client panic handler

// RMessage2::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

// (other items were commented in a header).

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

//

void PanicClient( const RMessage2& aMessage, TInt aPanic )

    {

    TRACE(Print(_L("[CmMdh Server]\t PanicClient: Reason = %d\n"), aPanic));

    aMessage.Panic( KCmMdhServerPanic, aPanic );

    }

// End of File