/*

* Copyright (c) 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:  BS Server - implemenration of CServer2 

 *

*/

#include <eikenv.h>

#include <eikappui.h>

#include <apgwgnam.h>

#include <e32base.h>

#include "bsengineglobals.h"

#include "bsengine.h"

#include "bsserversession.h"

#include "bsdebug.h"

#include "bsserver.h"

const TInt idsArrayGranularity = 30;

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

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

// C++ default constructor can NOT contain any code, that might leave.

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

//

CBSServer::CBSServer( TInt aPriority ) :

    CServer2(aPriority)

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CBSServer::ConstructL()

    {

    DEBUG(("Start BS Server" ));

    iEngine = CBSEngine::NewL( );

    StartL( KBSEngineName );

    }

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

// Two-phased constructor.

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

//

CBSServer* CBSServer::NewLC()

    {

    CBSServer* self = new( ELeave ) CBSServer( EPriorityNormal );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// Destructor.

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

//

CBSServer::~CBSServer()

    {

    DEBUG(("Destroy BS Server" ));

    delete iEngine;

    }

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

// Create new session.

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

//

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

    const RMessage2& /*aMessage*/ ) const

    {

    // Check we're the right version

    if ( !User::QueryVersionSupported( TVersion( KBSEngineMajorVersionNumber,

        KBSEngineMinorVersionNumber, KBSEngineBuildVersionNumber ), aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    return CBSServerSession::NewL( ( CBSServer* ) this );

    }

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

// Increment sessions.

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

//

void CBSServer::IncrementSessions()

    {

    iSessionCount++;

    }

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

// Decrement sessions.

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

//

void CBSServer::DecrementSessions()

    {

    iSessionCount--;

    }

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

// RunError is called when RunL leaves.

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

//

TInt CBSServer::RunError( TInt aError )

    {

    DEBUG(("CBSServer::RunError %d", aError ));

    if ( aError == KErrBadDescriptor )

        {

        PanicClient( Message( ), EBSEngineBadDescriptor );

        }

    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;

    }

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

// Panic client.

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

//

void CBSServer::PanicClient( const RMessage2& aMessage, TBSEnginePanic aPanic )

    {

    aMessage.Panic( KBSEngineName, aPanic );

    }

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

// Panic server.

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

//

void CBSServer::PanicServer( TBSEnginePanic aPanic )

    {

    User::Panic( KBSEngineName, aPanic );

    }

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

// Create and start the server.

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

//

void CBSServer::ThreadFunctionL()

    {

    CBSAppUi* ui = new (ELeave) CBSAppUi;

    ui->ConstructL( );

    // Construct our server        

    CBSServer* server = CBSServer::NewLC( );

    // set engine to AppUI to get notification about focus changes

    ui->iEngine = &(server->Engine( ));

    RProcess::Rendezvous( KErrNone );

    // Start handling requests

    CActiveScheduler::Start( );

    CleanupStack::PopAndDestroy( server );

    ui->PrepareToExit( );

    }

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

// Create and start the server.

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

//

TInt CBSServer::ThreadFunction()

    {

    __UHEAP_MARK;

    User::RenameThread( KBSEngineThreadName );

    CBSEikonEnv* env = new CBSEikonEnv;

    __ASSERT_ALWAYS( env, PanicServer( EBSEngineEIkonEnv ) );

    TRAPD(error, env->ConstructL(););

    __ASSERT_ALWAYS( !error, PanicServer( EBSEngineEIkonEnv ) );

    TRAPD( err, ThreadFunctionL() );

    if ( err != KErrNone )

        {

        PanicServer( EBSEngineSrvCreateServer );

        }

    env->DestroyEnvironment( );

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// Getter of engine

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

//

CBSEngine& CBSServer::Engine()

    {

    return *iEngine;

    }

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

// 

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

//

void CBSServer::CBSEikonEnv::DestroyEnvironment()

    {

    CEikonEnv::DestroyEnvironment( );

    }

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

// 

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

//

void CBSServer::CBSEikonEnv::ConstructL()

    {

    CEikonEnv::ConstructL( EFalse ); 

    SetAutoForwarding(ETrue); 

    User::SetPriorityControl(EFalse);

    }

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

// 

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

//

CBSServer::CBSAppUi::~CBSAppUi()

    {

    }

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

// 

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

//

void CBSServer::CBSAppUi::HandleWsEventL( const TWsEvent& aEvent,

    CCoeControl* /*aDestination*/)

    {

    if ( aEvent.Type( ) == EEventFocusGroupChanged 

        || aEvent.Type( ) == EEventWindowGroupsChanged )

        {

        TInt windowsGroupID = iCoeEnv->WsSession().GetFocusWindowGroup( );

        CApaWindowGroupName* apaWGName = CApaWindowGroupName::NewLC(

            iCoeEnv->WsSession( ), windowsGroupID );

        TUid uid = apaWGName->AppUid( );

        CleanupStack::PopAndDestroy( apaWGName );

        // if UID is 0, ignore event. 

        // Next event should bring correct information

        if ( uid.iUid )

            {

            iEngine->HandleFocusChangeL( uid );

            }

        }

    else if( aEvent.Type( ) == EEventKeyDown ) 

        {

        iEngine->ApplicationKeyWasPressed( );

        ForwardEventL( aEvent );     

        }

    else if( aEvent.Type( ) == EEventKeyUp )

        {

        ForwardEventL( aEvent );     

        }

    }

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

// 

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

//

void CBSServer::CBSAppUi::ForwardEventL( const TWsEvent& aEvent )

    {

    CArrayFixFlat<TInt>* idArray = 

                    new (ELeave) CArrayFixFlat<TInt>( idsArrayGranularity );

    iCoeEnv->WsSession().WindowGroupList( idArray );

    TInt ownId = iCoeEnv->RootWin().Identifier();

    for( TInt x(0); x < idArray->Count(); x++ )

        {

        if( (*idArray)[x] != ownId )

            {

            iCoeEnv->WsSession().SendEventToWindowGroup( 

                                                    (*idArray)[x], aEvent );

            }

        }

    delete idArray;

    }

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

// 

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

//

void CBSServer::CBSAppUi::ConstructL()

    {

    CEikAppUi::BaseConstructL( ENoAppResourceFile | ENoScreenFurniture );

    //get notifications about focus change events    

    iCoeEnv->RootWin().EnableFocusChangeEvents( );

    //get notifications about windows group change events    

    iCoeEnv->RootWin().EnableGroupChangeEvents( );

    //disable notifications about layout change

    iCoeEnv->RootWin().DisableScreenChangeEvents();

    //get notifications about application key event

    iCoeEnv->RootWin().CaptureKeyUpAndDowns( EStdKeyApplication0, 0, 0 );

    }

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

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

// E32Main item point.

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

//

TInt E32Main()

    {

    return CBSServer::ThreadFunction( );

    }

// End of File