/*
* 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:  Definition of MDispatcher interface that used
*        to dispatch incoming messages to servers
*        and outcoming to host client.
*        MDispatcher* should be used by services to send outcoming
*        messages
*
*/


#ifndef DISPATCHERINTERFACE_H__
#define DISPATCHERINTERFACE_H__

#include <e32std.h>

class CHtiMessage;
class CConsoleBase;

enum THtiMessagePriority
    {
    EHtiPriorityDefault = 0,
    EHtiPriorityData = 0,
    EHtiPriorityControl = 2
    };

const TInt KErrorDescriptionMaxLength = 118;

/**
* Observer interface that should be implemented by plugin if it wants
* to resend message failed due to KErrNoMemory.
**/
class MHtiMemoryObserver
    {
public:
    /**
    *
    * This function called by the dispatcher after plug-in request
    * (@see MHtiDispatcher::AddMemoryObserver()) every time
    * when some message was removed from the outgoing queue.
    *
    * @param aAvailableMemory amount of memory currently available for
    *           outgoing messages
    **/
    virtual void NotifyMemoryChange(TInt aAvailableMemory) = 0;
    };

/**
* Interface to the HTI dispatcher used by service plug-ins for message
* sending.
**/
class MHtiDispatcher
    {
public:

    /**
    *
    * Send message from the service back to host client.
    * Transfer ownership of aMessage.
    * The function adds messages to the outgoing queue.
    * Message will be actualy sent later.
    * Function can return KErrNoMemory if there is not enough memory to
    * add it to the queue.
    * Plug-in use AddMemoryObserver to be notified later when memory
    * will be available to continue data transfer.
    *
    * @param aMessage contain server-specific data
    * @param aTargetServiceUid service UID
    * @param aWrappedFlag shoud set to ETrue if message should be
    *       wrapped by security manager
    * @param aPriority message priority
    *
    * @return KErrNone if message was succesfully added to the outgoing queue
    *         KErrNoMemory when there is not enough memory.
    */
    virtual TInt DispatchOutgoingMessage( TDesC8* aMessage,
                    const TUid aTargetServiceUid,
                    TBool aWrappedFlag,
                    THtiMessagePriority aPriority ) = 0;

    virtual TInt DispatchOutgoingMessage(TDesC8* aMessage,
                    const TUid aTargetServiceUid) = 0;

    virtual TInt DispatchOutgoingErrorMessage(TInt aErrorCode,
                    const TDesC8& aErrorDescription,
                    const TUid aTargetServiceUid) = 0;
    /**
    * Adds memory observer.
    *
    * @param anObserver memory observer
    */
    virtual void AddMemoryObserver(MHtiMemoryObserver* anObserver) = 0;

    /**
    * Removes memory observer.
    *
    * @param anObserver memory observer
    */
    virtual void RemoveMemoryObserver(MHtiMemoryObserver* anObserver) = 0;

    /**
    * Returns tha amount of currenly available memory for messages.
    */
    virtual TInt GetFreeMemory() = 0;

    /**
    * Notifis dispatcher that some async request is over.
    * Should be used when plug-in uses async services
    * and enters in a busy state (IsBusy() returns true)
    * Should be called when plug-in is able to process new messages again
    */
    virtual void Notify( TInt anError ) = 0;

    /*
    * Getter for the HTI console
    */
    virtual CConsoleBase* GetConsole() = 0;

    /*
    * Shutdown HTI and reboot the device.
    *
    * Called from service plug-ins or from EHtiReboot HtiSystem command
    */
    virtual void ShutdownAndRebootDeviceL() = 0;
    };

#endif