/*

* Copyright (c) 2009 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:

*

*/

// INCLUDE FILES

#include "menusrv.h"

#include "menusrvdef.h"

#include "menusrvsession.h"

#include "timeout.h"

#include "menumsg.h"

#include "menuutil.h"

#include "menusrveng.h"

// CONSTANTS

// Custom check is applied to all IPCs. As IPC ids contain not only the ids

// but other information is embadded into them.

LOCAL_D const TInt KRangeCount = 1;

LOCAL_D const TInt KSecurityRanges[KRangeCount] = 

    {

    EMenuNullFunction,

    };

LOCAL_D const TUint8 SecurityRangesPolicy[KRangeCount] =

    {

    CPolicyServer::ECustomCheck

    };

LOCAL_D const CPolicyServer::TPolicy KPolicy =

    {

    CPolicyServer::EAlwaysPass,

    KRangeCount,

    KSecurityRanges,

    SecurityRangesPolicy,

    NULL,

    };

// ==================== LOCAL FUNCTIONS ====================

/**

* Stop the Active Scheduler.

* @param aPtr Not used.

* @return KErrNone.

*/

LOCAL_C TInt StopScheduler( TAny* /*aPtr*/ )

    {

    // Called by the exit timer, after all clients disconnected (plus a small

    // delay). Stop the scheduler, this will enable he thread exit.

    CActiveScheduler::Stop();

    return KErrNone;

    }

/**

* Create a server.

* @param Pointer to created server (if created) returned here.

* @return Error code.

*/

LOCAL_C TInt CreateServer( CMenuSrv*& aServer )

    {

    // The TRAP is not working in the same stack frame where the

    // CTrapCleanup was created. This is why we need this function.

    TRAPD( err, aServer = CMenuSrv::NewL() );

    return err;

    }

// ==================== GLOBAL FUNCTIONS ====================

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

// RunMenuServer

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

//

EXPORT_C TInt RunMenuServer()

    {

    __UHEAP_MARK;

    CTrapCleanup* trapCleanup = NULL;

    CActiveScheduler* activeScheduler = NULL;

    CMenuSrv* server = NULL;

    TInt err = User::RenameThread( KMenuSrvName );

    if ( !err )

        {

        // Create a trap cleanup, make and install an active scheduler.

        err = KErrNoMemory;

        trapCleanup = CTrapCleanup::New();

        if ( trapCleanup )

            {

            activeScheduler = new CActiveScheduler();

            if ( activeScheduler )

                {

                CActiveScheduler::Install( activeScheduler );

                err = CreateServer( server );   // Not pushed (no leaving).

                if ( !err )

                    {

                    err = server->Start( KMenuSrvName );

                    }

                }

            else

            	{

            	err = KErrNoMemory;

            	}

            }

        }

    // Let the caller know how it went.

    RProcess::Rendezvous( err );

    if ( !err )

        {

        CActiveScheduler::Start(); // Start off. Exit timer will stop it.

        }

    CActiveScheduler::Install( NULL );

    delete activeScheduler;

    delete server;

    delete trapCleanup;

    __UHEAP_MARKEND;

    return err;

    }

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

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

// CMenuSrv::NewL

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

//

CMenuSrv* CMenuSrv::NewL()

    {

    CMenuSrv* srv = new (ELeave) CMenuSrv();

    CleanupStack::PushL( srv );

    srv->ConstructL();

    CleanupStack::Pop( srv );

    return srv;

    }

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

// CMenuSrv::~CMenuSrv

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

//

CMenuSrv::~CMenuSrv()

    {

    // Cancel requests and delete all sessions first.

    // Base class would do it for us but that's too late - our sessions

    // call the server back (SessionClosed, RemoveContainer, etc.).

    Cancel();

    CSession2* session;

    iSessionIter.SetToFirst();

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

        {

        delete session;

        }

    // Here we should have no objects that are dependent on us.

    delete iObjectConIx; // This kills iEngines too.

    delete iExitTimer;

    }

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

// CMenuSrv::NewContainerL

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

//

CObjectCon* CMenuSrv::NewContainerL()

    {

    return iObjectConIx->CreateL();

    }

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

// CMenuSrv::RemoveContainer

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

//

void CMenuSrv::RemoveContainer( CObjectCon* aCon )

    {

    iObjectConIx->Remove( aCon );

    }

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

// CMenuSrv::GetEngineL

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

//

CMenuSrvEng* CMenuSrv::GetEngineL( const TDesC& aName )

    {

    CMenuSrvEng* eng = NULL;

    for ( TInt i = 0; i < iEngines->Count(); i++ )

        {

        eng = (CMenuSrvEng*)(*iEngines)[i];

        if ( eng->ContentName() == aName )

            {

            return eng;

            }

        }

    eng = CMenuSrvEng::NewL( *this, aName );

    CleanupClosePushL( *eng );

    iEngines->AddL( eng );

    CleanupStack::Pop( eng );

    return eng;

    }

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

// CMenuSrv::EngineDeleted

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

//

void CMenuSrv::EngineDeleted()

    {

    if ( 1 >= iEngines->Count() )

        {

        // Last engine is being deleted now.

        // Exit now, without delay: the engines had the timeout.

        //

        // Engine count is 1 when the engine has been created and added.

        // Engine count is 0 in case of leave in GetEngineL().

        iExitTimer->Cancel();

        CActiveScheduler* currentScheduler = CActiveScheduler::Current();

        // No more sessions; schedule self-deletion.

        if (currentScheduler)

            {

            iExitTimer->After( TTimeIntervalMicroSeconds32( 0 ) );

            }

        }

    }

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

// CMenuSrv::CMenuSrv

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

//

CMenuSrv::CMenuSrv()

: CPolicyServer( CActive::EPriorityStandard, KPolicy, ESharableSessions )

    {

    }

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

// CMenuSrv::ConstructL

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

//

void CMenuSrv::ConstructL()

    {

    iExitTimer = CTimeout::NewL

        ( CActive::EPriorityStandard, TCallBack( StopScheduler, NULL ) );

    iExitTimer->Cancel();

    iExitTimer->After( TTimeIntervalMicroSeconds32( KMenuSrvExitDelay ) );

    iObjectConIx = CObjectConIx::NewL();

    iEngines = iObjectConIx->CreateL();

    }

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

// CMenuSrv::NewSessionL

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

//

CSession2* CMenuSrv::NewSessionL

( const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const

    {

    TVersion version( KMenuMajorVersion, KMenuMinorVersion, KMenuBuild );

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

        {

        User::Leave( KErrNotSupported );

        }

    CSession2* session = CMenuSrvSession::NewL( (CMenuSrv&)*this );

    iExitTimer->Cancel();   // We have a client, cancel exit (if pending).

    return session;

    }

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

// CMenuSrv::CustomSecurityCheckL

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

//

CPolicyServer::TCustomResult CMenuSrv::CustomSecurityCheckL

    ( const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ )

    {

    TInt func = aMsg.Function();

    TCustomResult ret = EFail;

    if( func > EMenuTestCapabilityStart && 

        func < EMenuTestCapabilityEnd )

        {

        if( aMsg.HasCapability( ECapabilityAllFiles ) )

           {

           ret = EPass;

           }

        }

    else if( func > EMenuReadCapabilityStart && 

             func < EMenuReadCapabilityEnd )

        {

        if( aMsg.HasCapability( ECapabilityReadDeviceData ) )

           {

           ret = EPass;

           }

        }

    else if( func > EMenuWriteCapabilityStart && 

             func < EMenuWriteCapabilityEnd )

        {

        if( aMsg.HasCapability( ECapabilityWriteDeviceData ) )

           {

           ret = EPass;

           }

        }

    else

        {

        ;

        }

    return ret;

    }

//  End of File