/*

* Copyright (c) 2004 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 applications framework.

 *

 *

*/

#ifndef AKNSERVERAPP_H

#define AKNSERVERAPP_H

#include <eikserverapp.h>

/**

 * Allows a server app client to connect to a new server app, which

 * will be chained from the client app, giving it the appearance

 * of being embedded within the client.

 *

 * Series 60 client-side service IPC implementations should be

 * derived from this class.

 */

class RAknAppServiceBase : public REikAppServiceBase

    {

public:

    /**

    * Launch a new server app instance, which will be chained

    * from the current application.

    * Note, this function can only be used from the context of

    * an application thread, as it depends on the existence of

    * a CEikonEnv object.

    * If you want to launch a chained server app in a situation

    * where a CEikonEnv does not exist, use REikAppServiceBase::ConnectNewChildAppL()

    * instead.

    * @param aAppUid The UID of the server app which you wish to

    * launch.

    */

    IMPORT_C void ConnectChainedAppL(TUid aAppUid);

    /**

    * Close the server app session.

    */

    IMPORT_C void Close();

    };

/**

 * Interface for monitoring the lifetime of a server app.

 * This class adds Series 60 common behavior to the handling

 * of server app exits.

 */

class MAknServerAppExitObserver : public MApaServerAppExitObserver

    {

public: // from MApaServerAppExitObserver

    /**

    * Handle the exit of a connected server app.

    * This implementation provides Series 60 default behavior

    * for handling of the EAknCmdExit exit code. Derived classes

    * should base-call this implementation if they override this

    * function.

    * @param aReason The reason that the server application exited.

    * This will either be an error code, or the command id that caused

    * the server app to exit.

    */

    IMPORT_C virtual void HandleServerAppExit(TInt aReason);

    };

/**

 * Base class for server app service IPC implementations.

 * This class provides notifications of service creation and

 * destruction to the server, to give the server the ability

 * to handle the case where all clients have closed their

 * sessions.

 */

class CAknAppServiceBase : public CApaAppServiceBase

    {

public:

    /**

    * Constructor

    */

    IMPORT_C CAknAppServiceBase();

    /**

    * Destructor

    */

    IMPORT_C ~CAknAppServiceBase();

protected: // from CSession2

    /**

    * Override of CSession2::CreateL().

    * If further overridden, this function must be base-called.

    */

    IMPORT_C void CreateL();

    /**

    * Override of CSession2::ServiceL().

    * If further overridden, this function must be base-called.

    * @param aMessage The client message

    */

    IMPORT_C void ServiceL(const RMessage2& aMessage);

    /**

    * Override of CSession2::ServiceError().

    * If further overridden, this function must be base-called.

    * @param aMessage The client message.

    * @param aError The error code to which occured during message servicing

    */

    IMPORT_C void ServiceError(const RMessage2& aMessage,TInt aError);

    };

/**

 * Base class for server app's servers.

 * Series 60 applications that want to implement services should

 * derive their server class from this.

 * This class already supports the standard Series 60 services,

 * and is instantiated by default if an application is launched

 * as a server app, but does not override CAknApp::NewServerAppL().

 */

class CAknAppServer : public CEikAppServer

    {

public: // from CAknAppServer

    /**

    * Destructor

    */

	IMPORT_C ~CAknAppServer();

    /**

    * Second stage construction.

    * Derived classes may override this to add extra second

    * stage constuction, but they must base-call.

    * @param aFixedServerName the name that this server will have,

    * must be passed through in the base-call.

    */

    IMPORT_C void ConstructL(const TDesC& aFixedServerName);

    /**

    * Create a new service implementation.

    * This implementation creates common Series 60 services.

    * Derived classes can override this to add support for specific

    * services that they support. They must base-call for any

    * service UIDs that they do not support.

    * @param aServiceType the UID of the service that has been requested

    * @return a new service instance of the type requested

    */

    IMPORT_C CApaAppServiceBase* CreateServiceL(TUid aServiceType) const;

public: // new

    /**

    * Allows the server to handle the case when all client sessions

    * have closed.

    * The default implementation provides the Series 60 policy of

    * closing the server application. If this is not appropriate for

    * a server app, it should override this function to provide its

    * own behavior.

    */

    IMPORT_C virtual void HandleAllClientsClosed();

public: // not exported

    void HandleSessionClose();

    void HandleSessionOpen();

private:

    TInt iSessionCount;

    };

#endif

// End of file.