/*
* Copyright (c) 2008 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:  This is the implementation of application class
*
*/


#include <e32svr.h>

#include "layoutmgr.h"
#include "server.h"
#include "session.h"
#include "shutdown.h"
#include "library.h"
#include "mapping.h"
#include "debug.h"


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

CLayoutServer::CLayoutServer()
        : CGenericServer(CActive::EPriorityStandard),
        iIsNokiaSu8(EFalse), iFoundLayout(EFalse)
    {
    // nothing else to do
    }

CLayoutServer::~CLayoutServer()
    {
    TRACE_FUNC ( _L("[HID]\t~CLayoutServer") );
    delete iLayoutLibrary;
    delete iShutdown;
    }

CLayoutServer* CLayoutServer::NewL()
    {
    CLayoutServer* self = CLayoutServer::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

CLayoutServer* CLayoutServer::NewLC()
    {
    CLayoutServer* self = new (ELeave) CLayoutServer;
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

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

void CLayoutServer::ConstructL()
    {
    TRACE_FUNC( (_L("[HID]\tCLayoutServer::ConstructL()") ));
    // Construct delayed shutdown timer:
    iShutdown = CLayoutMgrShutdown::NewL();

    // Need a keyboard layout library:
    iLayoutLibrary = CLayoutLibrary::NewL();

    // Start the server:
    StartL(KLayoutServerName);

    // Shut down after a few seconds unless a client connects:
    iShutdown->Start();
    }

// ----------------------------------------------------------------------
CSession2* CLayoutServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
    {
    // Version number of this server software:
    const TVersion KServerVersion(1, 0, 0);

    // Ensure we're compatible with the client:
    if (!User::QueryVersionSupported(KServerVersion, aVersion))
        {
        User::Leave(KErrNotSupported);
        }

    CLayoutSession* session = CLayoutSession::NewL();
    const_cast<CLayoutServer*>(this)->SessionAdded();

    return session;
    }

void CLayoutServer::SessionAdded()
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::SessionAdded() count %d"),iSessionCount+1));

    ++iSessionCount;
    iShutdown->Cancel();
    }

void CLayoutServer::SessionClosed()
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::SessionClosed(), count %d"),iSessionCount-1));

    --iSessionCount;
    __ASSERT_DEBUG(iSessionCount >= 0, PanicServer(ENegativeSessionCount));

    if (iSessionCount < 1)
        {
        iSessionCount = 0;

        // If that was the last session, shut down the server:
        iShutdown->Start();
        }
    }

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

// ServiceL() leaves will end up here:
//
TInt CLayoutServer::RunError(TInt aErr)
    {
    if (aErr == KErrBadDescriptor)
        {
        PanicClient(Message(), EBadDescriptor);
        }
    else
        {
        // Report the error to the client:
        Message().Complete(aErr);
        }

    // The leave will result in an early return from CServer::RunL(),
    // skipping the call to request another message. So we do that now
    // in order to keep the server running:
    ReStart();

    return KErrNone; // handled the error fully
    }

// ----------------------------------------------------------------------
void CLayoutServer::PanicClient(const RMessage2& aMessage, TInt aPanic)
    {
    __DEBUGGER();
    aMessage.Panic(KLayoutServerPanic, aPanic);
    }

void CLayoutServer::PanicServer(TInt aPanic)
    {
    __DEBUGGER();
    User::Panic(KLayoutServerPanic, aPanic);
    }

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

void CLayoutServer::ThreadFunctionL(TStartupRequest* /*aStartup*/)
    {
    // This is a new thread, so we require a new active scheduler:
    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
    CleanupStack::PushL(activeScheduler);
    CActiveScheduler::Install(activeScheduler);

    // Construct our server
    CLayoutServer::NewLC();

    User::RenameThread(KLayoutServerName);
    RProcess::Rendezvous(KErrNone);

    // Start handling requests:
    CActiveScheduler::Start();

    // Server finished:
    CleanupStack::PopAndDestroy(2, activeScheduler);
    }

TInt CLayoutServer::ThreadFunction(TAny* aThreadArg)
    {
    __UHEAP_MARK;

    TInt err = KErrNone;
    TStartupRequest* startup = static_cast<TStartupRequest*>(aThreadArg);

    CTrapCleanup* cleanupStack = CTrapCleanup::New();
    if (cleanupStack)
        {
        TRAP(err, ThreadFunctionL(startup));
        delete cleanupStack;

        if (err != KErrNone)
            {
            // Failed, but we must still signal the client or it will
            // hang:
            RProcess::Rendezvous(err);
            }
        }
    else
        {
        // Again, failed, but we still need to signal the client:
        RProcess::Rendezvous(KErrNoMemory);
        }

    __UHEAP_MARKEND;

    return err;
    }

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

void CLayoutServer::SetInitialLayoutL(TInt aCountry,
                                      TInt aVendor, TInt aProduct)
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::SetInitialLayoutL(%d, %d, %d)\n"),
                 aCountry, aVendor, aProduct));

    // Select an initial layout ID based on parameters read from the device:
    TFindLayoutId findLayout(aCountry, aVendor, aProduct);
    iInitialLayout = findLayout.LayoutId();
    iIsNokiaSu8 = findLayout.IsNokiaSu8();
    iFoundLayout = findLayout.FoundLayout();

    TRACE_INFO( (_L("[HID]\t  Layout ID is %d (0x%x)\n"),
                 iInitialLayout, iInitialLayout));

    // Set this as the system keyboard layout:
    User::LeaveIfError(SetLayout(iInitialLayout));
    }

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

TInt CLayoutServer::SetLayout(TInt aLayoutId)
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::SetLayout(%d)\n"), aLayoutId) );

    // Change the single system keyboard layout:

    TInt err = iLayoutLibrary->SetLayout(aLayoutId);

    if (err == KErrNone)
        {
        // Notify each driver in turn:
        TRACE_INFO( (_L("[HID]\t iSessionCount = %d\n"), iSessionCount));
        TDblQueIter<CSession2> sessionList = iSessionIter;
        sessionList.SetToFirst();

        CSession2* session = sessionList++;

        while (session)
            {

            // We know that each session is actually a CLayoutSession:
            CLayoutSession* lsession = static_cast<CLayoutSession*>(session);
            lsession->SetLayout(iLayoutLibrary);
            session = sessionList++;
            }
        }

    return err;
    }

TInt CLayoutServer::Layout() const
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::Layout() = %d\n"),
                 iLayoutLibrary->Id()));
    return iLayoutLibrary->Id();
    }

TInt CLayoutServer::InitialLayout() const
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::InitialLayout() = %d\n"),
                 iInitialLayout));
    return iInitialLayout;
    }

TBool CLayoutServer::IsNokiaSu8() const
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::IsNokiaSu8() = %d\n"),
                 iIsNokiaSu8));
    return iIsNokiaSu8;
    }

TBool CLayoutServer::FoundLayout() const
    {
    TRACE_INFO( (_L("[HID]\tCLayoutServer::FoundLayout() = %d\n"),
                 iFoundLayout));
    return iFoundLayout;
    }

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

TInt E32Main()
    {
    TStartupRequest startup;
    TInt error = CGenericServer::GetStartupFromCommandLine(startup);

    if (KErrNone == error)
        {
        error = CLayoutServer::ThreadFunction(&startup);
        }

    return error;
    }


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