/*

* Copyright (c) 2002-2005 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:  Client interface for EcmtServer

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include "EcmtClient.h"

#include "EcmtUids.h"

#include "EcmtClientServerCommon.h"

#include "EcmtServerListener.h"

_LIT(KEcmtServerFilename, "\\sys\\bin\\EcmtCore.exe");

const TInt KServerStartTimeout = 30000000; // 30 sec

const TInt KServerCheckTimeout = 1000000;  // 1 sec

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

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

// StartServer

// Starts the Ecmt server if it is not yet running.

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

static TInt StartServer()

{

    TFindServer findServer( KEcmtServerName );

    TFullName name;

    // Try to find Ecmt server

    TInt result = findServer.Next( name );

    if ( result != KErrNone )

    {

        // Server not yet running, so must launch it.

        // Create a semaphore that will be signaled by server when

        // it has completed its "boot" sequence.

        RSemaphore semaphore;

        result = semaphore.CreateGlobal( KEcmtSemaphoreName, 0 );

        if ( result == KErrNone || result == KErrAlreadyExists )

        {

            // Semaphore created succesfully (or it existed already)

            // so launch the server process.

            RProcess server;

            const TUid KEcmtServerUid = { KECMT_SERVER_UID };

            const TUidType serverUid( KNullUid, KNullUid, KEcmtServerUid );

            result = server.Create(KEcmtServerFilename, KNullDesC, serverUid);

            if (result == KErrNone)

            {

                server.Resume();

                TTime now, deadline;

                now.HomeTime();

                deadline.HomeTime();

                deadline += TTimeIntervalMicroSeconds32(KServerStartTimeout);

                result = KErrTimedOut;

                while (result == KErrTimedOut && now < deadline)

                {

                    result = (server.ExitType() == EExitPending) ?

                        semaphore.Wait(KServerCheckTimeout) : 

                        KErrGeneral;

                }

                server.Close();

            }

        }

        else

        {

            semaphore.Wait(KServerStartTimeout);

        }

        semaphore.Close();

    }

    return result;

}

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

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

// REcmt::REcmt

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

EXPORT_C REcmt::REcmt( ) : iServerListener(0)

{

}

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

// REcmt::~REcmt

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

EXPORT_C REcmt::~REcmt( )

{

    delete iServerListener;

}

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

// REcmt::Connect

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

EXPORT_C TInt REcmt::Connect( )

{

    // Start server (unless it is already running)

    TInt error = StartServer();

    if (KErrNone == error)

    {

        error = CreateSession( KEcmtServerName,

                               TVersion( KEcmtServerMajorVersionNumber,

                                         KEcmtServerMinorVersionNumber,

                                         KEcmtServerBuildVersionNumber ) );

    }

    return error;

}

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

// REcmt::Close

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

EXPORT_C void REcmt::Close( )

{

    if ( iServerListener )

    {

        delete iServerListener;

        iServerListener = 0;

    }

    RHandleBase::Close();

}

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

// REcmt::SetServerObserver

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

EXPORT_C void REcmt::SetServerObserverL( MEcmtServerObserver* /* aObserver */ )

{

    User::Leave( KErrNotSupported );

}

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

// REcmt::SetServerObserver

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

EXPORT_C void REcmt::SetServerObserverL( TUid aUid, MEcmtServerObserver* aObserver )

{

    iServerListener = new (ELeave) CEcmtServerListener( aObserver, *this ); 

    TIpcArgs messageParameters( aUid.iUid );

    SendReceive( EEcmtNotifyUid, messageParameters ); // ignore return code

}

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

// REcmt::RequestServerNotification

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

void REcmt::RequestServerNotification( TDes8& aDes, TRequestStatus& aStatus )

{

    TIpcArgs messageParameters( &aDes );

    SendReceive( EEcmtRequestServerNotification, messageParameters, aStatus );

}

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

// REcmt::CancelRequestServerMessage

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

void REcmt::CancelRequestServerNotification( )

{

    SendReceive( EEcmtCancelRequestServerNotification, TIpcArgs( ) );

}

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

// REcmt::Send

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

EXPORT_C void REcmt::Send( const TUint uid, const TDesC8& aData )

{

    TIpcArgs messageParameters( uid, &aData );

    SendReceive( EEcmtRequestSendData, messageParameters );

}

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

// REcmt::Write

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

EXPORT_C void REcmt::Write( const TDesC16& aText )

{

    TIpcArgs messageParameters( &aText );

    SendReceive( EEcmtRequestSendText, messageParameters );

}

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

// REcmt::WriteFormat

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

EXPORT_C void REcmt::WriteFormat( TRefByValue<const TDesC16> aFmt, ... )

{

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf16<KFormatMaxSize> buf;

    buf.FormatList( aFmt, list );

    Write( buf );

}

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

// REcmt::GetServer

// Returns thread local instance of REcmt client

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

REcmt* REcmt::GetServer()

{

    // Create a new REcmt reference for the static write functions, if a

    // reference has not been created earlier.

    REcmt* r = static_cast<REcmt*>(UserSvr::DllTls(KECMT_SERVER_UID));

    if (!r)

    {

        r = new REcmt();

        if (r)

        {

            TInt err = UserSvr::DllSetTls(KECMT_SERVER_UID, r);

            if (err == KErrNone)

            {

                r->Connect();

                if (err == KErrNone)

                {

                    return r;

                }

                // Cleanup

                UserSvr::DllSetTls(KECMT_SERVER_UID, NULL);

            }

            delete r;

            r = NULL;

        }

    }

    return r;

}

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

// REcmt::SWrite

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

EXPORT_C void REcmt::SWrite(const TDesC16& aText)

{

    REcmt* r = GetServer();

    if (r)

    {

        r->Write(aText);

    }

}

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

// REcmt::SWriteFormat

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

EXPORT_C void REcmt::SWriteFormat(TRefByValue<const TDesC16> aFmt, ...)

{

    REcmt* r = GetServer();

    if (r)

    {

        VA_LIST list;

        VA_START( list, aFmt );

        r->WriteFormat(aFmt, list);

    }

}

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

// REcmt::SClose

// Deallocates thread local instance of REcmt client

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

EXPORT_C void REcmt::SClose()

{

    // Don't use GetServer() here because it may create a new REcmt instance,

    // which would be exactly opposite to what we are trying to do here.

    REcmt* r = static_cast<REcmt*>(UserSvr::DllTls(KECMT_SERVER_UID));

    if (r)

    {

        r->Close();

        delete r;

        UserSvr::DllSetTls(KECMT_SERVER_UID, NULL);

    }

}

//  End of File