/* mbed Microcontroller Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef MBED_GATT_CLIENT_H__
#define MBED_GATT_CLIENT_H__

#include "ble/common/StaticInterface.h"
#include "ble/GattAttribute.h"
#include "ble/ServiceDiscovery.h"
#include "ble/CharacteristicDescriptorDiscovery.h"
#include "ble/GattCallbackParamTypes.h"
#include "ble/CallChainOfFunctionPointersWithContext.h"
#include "BleImplementationForward.h"

#if !defined(DOXYGEN_ONLY)
namespace ble {
namespace interface {
#endif

/**
 * @addtogroup ble
 * @{
 * @addtogroup gatt
 * @{
 * @addtogroup client
 * @{
 */

/**
 * Define procedures required for interacting with a distant GATT server.
 *
 * @par Discovery procedures
 *
 * A GATT server hosts a fixed set of services. These services are a logical
 * composition of characteristics that may be discovered, read, written or also
 * broadcast their state to a connected client. These characteristics may also
 * contain metainformation named characteristic descriptors. A characteristic
 * descriptor may be used to indicate the unit used for a characteristic value,
 * describe in a textual form the characterisic purpose or allow a client to
 * register for notification of updates of the characteristic value.
 *
 * Prior to any interaction with server characteristic, a GATT client
 * discovers the layout of the services and characteristics present on the
 * server.
 *
 * The layout of the descriptors of a characteristic may also be issued to
 * as an extra discovery step.
 *
 * @par Attribute manipulation
 *
 * As a result of the discovery process, the client can start interacting with
 * the characteristic discovered. Depending on the characteristic properties
 * (acquired during discovery), a client can read or write the value of a given
 * characteristic.
 *
 * Mbed BLE abstracts most read and write operations to offer a single API that
 * can be used to read or write characteristics values. Application code does not
 * have to handle the fragmentation/reassembly process necessary if the attribute
 * value to transported cannot fit in a single data packet.
 *
 * @par Server Initiated events
 *
 * If a characteristic has to notify or indicate a property set; then, a client may
 * register to a notification or indication from the characteristic. When the
 * server updates the characteristic value, the server can forward the
 * new value to the registered clients. The notification/indication mechanism
 * prevents polling from the client and therefore minimize the transactions
 * involved between a client and a server.
 *
 * Registration is made by writing the Client Characteristic Configuration
 * Descriptor, which is present in the characteristic if the notify or
 * indicate properties are set. The client discovers that descriptor
 * if it intends to register to server initiated events.
 */
#if defined(DOXYGEN_ONLY)
class GattClient {
#else
template <class Impl>
class GattClient : public StaticInterface<Impl, GattClient> {
#endif

    using StaticInterface<Impl, ::ble::interface::GattClient>::impl;

public:

    /**
     * Definition of the general handler of GattClient related events.
     */
    struct EventHandler {
        /**
         * Function invoked when the connections changes the ATT_MTU which controls
         * the maximum size of an attribute that can be read in a single L2CAP packet
         * which might be fragmented across multiple packets.
         *
         * @param connectionHandle The handle of the connection that changed the size.
         * @param attMtuSize
         */
        virtual void onAttMtuChange(
            ble::connection_handle_t connectionHandle,
            uint16_t attMtuSize
        )
        {
        }
    };

    /**
     * Assign the event handler implementation that will be used by the
     * module to signal events back to the application.
     *
     * @param handler Application implementation of an EventHandler.
     */
    void setEventHandler(EventHandler *handler)
    {
        eventHandler = handler;
    }

    /**
     * Attribute read event handler.
     *
     * @see GattClient::onDataRead().
     */
    typedef FunctionPointerWithContext<const GattReadCallbackParams*>
        ReadCallback_t;

    /**
     * Callchain of attribute read event handlers.
     */
    typedef CallChainOfFunctionPointersWithContext<const GattReadCallbackParams*>
        ReadCallbackChain_t;

    /**
     * GATT write operations.
     */
    enum WriteOp_t {
        /**
         * Write request.
         *
         * It is used to request the server to write the value of an attribute
         * and acknowledge that this has been achieved in a Write Response.
         */
        GATT_OP_WRITE_REQ = 0x01,

        /**
         * Write command.
         *
         * It is used to request the server to write the value of an attribute.
         * The server does not acknowledge the status of the operation.
         */
        GATT_OP_WRITE_CMD = 0x02,

        /**
         * Signed Write command.
         *
         * It is used to request the server to write the value of an attribute
         * using a signed packet. The server does not acknowledge the status
         * of the operation.
         */
        GATT_OP_SIGNED_WRITE_CMD = 0x03
    };

    /**
     * Attribute write event handler.
     *
     * @see GattClient::onDataWrite().
     */
    typedef FunctionPointerWithContext<const GattWriteCallbackParams*>
        WriteCallback_t;

    /**
     * Callchain of attribute write event handlers.
     *
     * @see GattClient::onDataWrite().
     */
    typedef CallChainOfFunctionPointersWithContext<const GattWriteCallbackParams*>
        WriteCallbackChain_t;

    /**
     * Handle value notification/indication event handler.
     *
     * @see to GattClient::onHVX().
     */
    typedef FunctionPointerWithContext<const GattHVXCallbackParams*>
        HVXCallback_t;

    /**
     * Callchain of handle value notification/indication event handlers.
     *
     * @see GattClient::onHVX().
     */
    typedef CallChainOfFunctionPointersWithContext<const GattHVXCallbackParams*>
        HVXCallbackChain_t;

    /**
     * Shutdown event handler.
     *
     * @see GattClient::onShutdown().
     */
    typedef FunctionPointerWithContext<const GattClient *>
        GattClientShutdownCallback_t;


    /**
     * Callchain of shutdown event handlers.
     *
     * @see to GattClient::onShutown().
     */
    typedef CallChainOfFunctionPointersWithContext<const GattClient *>
        GattClientShutdownCallbackChain_t;

    /*
     * The following functions are meant to be overridden in the platform
     * specific subclass.
     */
public:

    ~GattClient() { }

    /**
     * Launch the service and characteristic discovery procedure of a GATT server
     * peer.
     *
     * The procedure invokes application callbacks for matching services or
     * characteristics. The process ends after all the services and
     * characteristics present on the distant GATT server have been discovered.
     * Termination callbacks registered with onServiceDiscoveryTermination() are
     * invoked to notify the application of the termination of the procedure.
     *
     * Application code can track the status of the procedure by invoking the
     * function isServiceDiscoveryActive(), which returns true if the
     * procedure is ongoing.
     *
     * At any point, application code can prematurely terminate the discovery
     * procedure by calling terminateServiceDiscovery().
     *
     * @param[in] connectionHandle Handle of the connection with the peer GATT
     * server.
     * @param[in] sc Service discovered event handler invoked when a matching
     * service has been discovered. This parameter may be NULL.
     * @param[in] cc Characteristic discovered event handler invoked when a
     * matching characteristic has been found. This parameter may be NULL.
     * @param[in] matchingServiceUUID UUID of the service the caller is
     * interested in. If a service discovered matches this filter, then @p sc is
     * invoked with it. The special value BLE_UUID_UNKNOWN acts as a wildcard,
     * which can be used to discover all services present on the peer GATT
     * server.
     * @param[in] matchingCharacteristicUUIDIn UUID of the characteristic the
     * caller is interested in. If a characteristic discovered matches this
     * filter, then @p cc is  invoked with it. The special value BLE_UUID_UNKNOWN
     * acts as a wildcard, which can be used to discover all services present on
     * the peer GATT server.
     *
     * @par Discovery procedure implementation detail
     *
     * It is recommended to implement several strategies based on the
     * combination of callbacks and filters passed in input to efficiently
     * realize the discovery procedure:
     * - If @p sc and @p cc are NULL, then it is not necessay to initiate any
     * discovery, and the termination handlers can be invoked immediately.
     * - If @p matchingServiceUUID is set, then the GATT discover services by
     * service UUID procedure should be used; otherwise, the GATT discover primary
     * services procedure should be used.
     * - If @p cc is NULL, then the discovery process should end after the discovery
     * of the services.
     *
     * @return BLE_ERROR_NONE if the discovery procedure has been successfully
     * started and an appropriate error otherwise.
     */
    ble_error_t launchServiceDiscovery(
        ble::connection_handle_t connectionHandle,
        ServiceDiscovery::ServiceCallback_t sc = NULL,
        ServiceDiscovery::CharacteristicCallback_t  cc = NULL,
        const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN),
        const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)
    );

    /**
     * Launch the service discovery procedure of a GATT server peer.
     *
     * The procedure invokes the application callback for matching services.
     * The process ends after all the services present on the distant GATT
     * server have been discovered.
     * Termination callbacks registered with onServiceDiscoveryTermination() are
     * invoked to notify the application of the termination of the procedure.
     *
     * Application code can track the status of the procedure by invoking the
     * function isServiceDiscoveryActive(), which returns true if the
     * procedure is ongoing.
     *
     * At any point, application code can prematurely terminate the discovery
     * procedure by calling terminateServiceDiscovery().
     *
     * @param[in] connectionHandle Handle of the connection with the peer GATT
     * server.
     * @param[in] callback Service discovered event handler invoked when a
     * matching service has been discovered. This parameter may be NULL.
     * @param[in] matchingServiceUUID UUID of the service the caller is
     * interested in. If a service discovered matches this filter, then @p sc is
     * invoked with it. The special value BLE_UUID_UNKNOWN act is a wildcard,
     * which can be used to discover all services present on the peer GATT
     * server.
     *
     * @return BLE_ERROR_NONE if the discovery procedure has been successfully
     * started and an appropriate error otherwise.
     */
    ble_error_t discoverServices(
        ble::connection_handle_t connectionHandle,
        ServiceDiscovery::ServiceCallback_t callback,
        const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)
    ) {
        /* We take advantage of the property
         * that providing NULL for the characteristic callback results in
         * characteristic discovery being skipped for each matching
         * service. This allows for an inexpensive method to discover only
         * services. Porters are free to override this. */
        return launchServiceDiscovery(
            connectionHandle, callback, NULL, matchingServiceUUID
        );
    }

    /**
     * Launch the service discovery procedure of a GATT server peer.
     *
     * The process ends after all the services present in the attribute range @p
     * startHandle to @p endHandle have been discovered.
     *
     * Termination callbacks registered with onServiceDiscoveryTermination() are
     * invoked to notify the application of the termination of the procedure.
     *
     * Application code can track the status of the procedure by invoking the
     * function isServiceDiscoveryActive(), which returns true if the
     * procedure is ongoing.
     *
     * At any point, application code can prematurely terminate the discovery
     * procedure by calling terminateServiceDiscovery().
     *
     * @param[in] connectionHandle Handle of the connection with the peer GATT
     * server.
     * @param[in] callback Service discovered event handler invoked when a
     * matching service has been discovered. This parameter may be NULL.
     * @param[in] startHandle First attribute handle of the discovery range.
     * @param[in] endHandle end Lasr attribute handle of the discovery range.
     *
     * @return BLE_ERROR_NONE if the discovery procedure has been successfully
     * started and an appropriate error otherwise.
     */
    ble_error_t discoverServices(
        ble::connection_handle_t connectionHandle,
        ServiceDiscovery::ServiceCallback_t callback,
        GattAttribute::Handle_t startHandle,
        GattAttribute::Handle_t endHandle
    );

    /**
     * Check if the service discovery procedure is currently active.
     *
     * @return true if service discovery procedure is active and false otherwise.
     */
    bool isServiceDiscoveryActive(void) const;

    /**
     * Terminate all ongoing service discovery procedures.
     *
     * It results in an invocation of the service discovery termination handler
     * registered with onServiceDiscoveryTermination().
     */
    void terminateServiceDiscovery(void);

    /**
     * Initiate the read procedure of an attribute handle.
     *
     * Once the attribute value has been read in its entirety, the process issues
     * an attribute read event and passes it to all events handlers registered
     * by onDataRead.
     *
     * @param[in] connHandle Handle of the connection used to send the read
     * request.
     * @param[in] attributeHandle Handle of the attribute to read data from.
     * @param[in] offset The offset from the start of the attribute value to be
     * read.
     *
     * @return BLE_ERROR_NONE if read procedure successfully started.
     *
     * @par Implementation notes:
     *
     * Reading the attribute value in its entirety may involve sending several
     * GATT requests to the peer. The following algorithm may be used to
     * implement the process:
     *
     * If the offset is equal to 0, then send a read request; otherwise, send a
     * read blob request at the specified offset.
     *
     * While the attribute data in the response are MTU - 1 long:
     *   - Concat the response to the value containing the previous responses.
     *   - Increment the value of the offset by MTU - 1.
     *   - Send a read blob request with the updated offset.
     *
     * Finally, concat the last response with the value containing all the
     * previous responses and forward that value to the event handlers.
     */
    ble_error_t read(
        ble::connection_handle_t connHandle,
        GattAttribute::Handle_t attributeHandle,
        uint16_t offset
    ) const;

    /**
     * Initiate a write procedure on an attribute value.
     *
     * If @p cmd is equal to GATT_OP_WRITE_REQ, then the status of the operation
     * is reported to the event handlers registered through onDataWritten().
     *
     * @param[in] cmd Type of the write procedure used. If GATT_OP_WRITE_CMD
     * is set, then value length is not greater than the size of the mtu
     * of connHandle minus three.
     * @param[in] connHandle Handle of the connection used to send the write
     * request or command.
     * @param[in] attributeHandle Handle of the attribute value to write.
     * @param[in] length Number of bytes present in @p value.
     * @param[in] value Data buffer to write to attributeHandle.
     *
     * @return BLE_ERROR_NONE if the write procedure successfully started.
     *
     * @par Implementation notes:
     *
     * If the operation is a write command, then an implementation uses the
     * GATT write without response procedure and an error is returned if
     * the data buffer to write is larger than the size of the MTU - 3.
     *
     * If the operation is a write command and the size of the data buffer to
     * write is less than than the size of the MTU - 3, then the ATT write request
     * procedure is used, and the response is reported to the handlers
     * listening for write response.
     *
     * Otherwise, the data buffer to write is divided in chunks with a
     * maximum size of MTU - 5. Those chunks are sent sequentially to the
     * peer in ATT prepare write requests. If an error response is received
     * during the process, the procedure ends immediately, the prepared
     * write is discarded and an error is reported to the application handlers.
     * Once all the chunks have been sent, the transaction is completed
     * by sending an execute write request to the peer. The peer response is
     * forwarded to the application handlers.
     */
    ble_error_t write(
        GattClient::WriteOp_t cmd,
        ble::connection_handle_t connHandle,
        GattAttribute::Handle_t attributeHandle,
        size_t length,
        const uint8_t *value
    ) const;

    /* Event callback handlers. */
public:

    /**
     * Register an attribute read event handler.
     *
     * @note It is possible to unregister a callback using
     * onDataRead().detach(callbackToRemove).
     *
     * @param[in] callback Event handler being registered.
     */
    void onDataRead(ReadCallback_t callback)
    {
        onDataReadCallbackChain.add(callback);
    }

    /**
     * Get the callchain of attribute read event handlers.
     *
     * @return A reference to the read event callback chain.
     *
     * @note It is possible to register new handlers using
     * onDataRead().add(callback).
     *
     * @note It is possible to unregister an handler by using
     * onDataRead().detach(callback).
     */
    ReadCallbackChain_t& onDataRead()
    {
        return onDataReadCallbackChain;
    }

    /**
     * Register an attribute write event handler.
     *
     * @param[in] callback Event handler being registered.
     *
     * @note It is possible to remove registered handlers using
     * onDataWritten().detach(callbackToRemove).
     *
     * @note Write commands (issued using writeWoResponse) don't generate a
     * response.
     */
    void onDataWritten(WriteCallback_t callback)
    {
        onDataWriteCallbackChain.add(callback);
    }

    /**
     * Get the callchain of attribute write event handlers.
     *
     * @return A reference to the data written callbacks chain.
     *
     * @note It is possible to register new handlers by using
     * onDataWritten().add(callback).
     *
     * @note It is possible to unregister an handler by using
     * onDataWritten().detach(callback).
     */
    WriteCallbackChain_t& onDataWritten()
    {
        return onDataWriteCallbackChain;
    }

    /**
     * Register an attribute write event handler.
     *
     * @param[in] callback Event handler being registered.
     *
     * @note It is possible to remove registered handlers using
     * onDataWritten().detach(callbackToRemove).
     *
     * @note Write commands (issued using writeWoResponse) don't generate a
     * response.
     *
     * @deprecated Use GattServer::onDataWritten().
     */
    MBED_DEPRECATED("Use GattServer::onDataWritten()")
    void onDataWrite(WriteCallback_t callback)
    {
        onDataWritten(callback);
    }

    /**
     * Register a service discovery termination event handler.
     *
     * @param[in] callback Event handler being registered.
     */
    void onServiceDiscoveryTermination(
        ServiceDiscovery::TerminationCallback_t callback
    );

    /**
     * Initiate the descriptor discovery procedure for a given characteristic.
     *
     * When a descriptor is discovered the discovered descriptor is forwarded
     * to @p discoveryCallback. After the discovery of all the descriptors, the
     * procedure ends and send a descriptor discovery termination event to @p
     * termination callback.
     *
     * Application code may monitor the discovery process by querying its status
     * with isCharacteristicDescriptorDiscoveryActive(). It can also end the
     * discovery process by calling terminateCharacteristicDescriptorDiscovery().
     *
     * @param[in] characteristic The characteristic owning the descriptors to
     * discover.
     * @param[in] discoveryCallback Handle descriptor discovered events for the
     * duration of the procedure.
     * @param[in] terminationCallback Handle descriptor discovery termination
     * event of the procedure.
     *
     * @return BLE_ERROR_NONE if the characteristic descriptor discovery
     * procedure has been launched successfully otherwise an appropriate error.
     */
    ble_error_t discoverCharacteristicDescriptors(
        const DiscoveredCharacteristic& characteristic,
        const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
        const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback
    );

    /**
     * Query status of the descriptor discovery procedure for a given
     * characteristic.
     *
     * @param[in] characteristic The characteristic concerned by the descriptors
     * discovery.
     *
     * @return true if a descriptors discovery is active for the characteristic
     * in input otherwise false.
     */
    bool isCharacteristicDescriptorDiscoveryActive(
        const DiscoveredCharacteristic& characteristic
    ) const;

    /**
     * @brief Terminate an ongoing characteristic descriptor discovery procedure.
     *
     * If the procedure is active, then it ends, and the termination handler
     * associated with the procedure is called.
     *
     * @param[in] characteristic The characteristic containing the descriptors
     * being discovered.
     */
    void terminateCharacteristicDescriptorDiscovery(
        const DiscoveredCharacteristic& characteristic
    );

    /**
     * Trigger MTU negotiation. This might result in a Gap event onAttMtuChange
     * being called if MTU changes.
     *
     * @note This does not guarantee a change in MTU size. If size remains
     * unchanged no event will be generated.
     *
     * @param connection Connection on which the MTU is to be negotiated.
     *
     * @return BLE_ERROR_NONE if the procedure has been launched successfully
     * otherwise an appropriate error.
     */
    ble_error_t negotiateAttMtu(ble::connection_handle_t connection);

    /**
     * Register an handler for Handle Value Notification/Indication events.
     *
     * @param callback Event handler to register.
     *
     * @note It is possible to unregister a callback by using
     * onHVX().detach(callbackToRemove).
     */
    void onHVX(HVXCallback_t callback)
    {
        onHVXCallbackChain.add(callback);
    }

    /**
     * Register a shutdown event handler.
     *
     * The registered handler is invoked when the GattClient instance is
     * about to be shut down.
     *
     * @param[in] callback Event handler to invoke when a shutdown event is
     * available.
     *
     * @note onShutdown().detach(callback) may be used to unregister a given
     * callback.
     *
     * @see BLE::shutdown()
     */
    void onShutdown(const GattClientShutdownCallback_t& callback)
    {
        shutdownCallChain.add(callback);
    }

    /**
     * Register a shutdown event handler.
     *
     * The registered handler is invoked when the GattClient instance is
     * about to be shut down.
     *
     * @param[in] objPtr Instance that will be used to invoke @p memberPtr.
     * @param[in] memberPtr Event handler to invoke when a shutdown event is
     * available.
     */
    template <typename T>
    void onShutdown(T *objPtr, void (T::*memberPtr)(const GattClient *))
    {
        shutdownCallChain.add(objPtr, memberPtr);
    }

    /**
     * Get the callchain of shutdown event handlers.
     *
     * @return A reference to the shutdown event callbacks chain.
     *
     * @note onShutdown().add(callback) may be used to register new handlers.
     *
     * @note onShutdown().detach(callback) may be used to unregister an handler.
     */
    GattClientShutdownCallbackChain_t& onShutdown()
    {
        return shutdownCallChain;
    }

    /**
     * @brief provide access to the callchain of HVX callbacks.
     *
     * @return A reference to the HVX callbacks chain.
     *
     * @note It is possible to register callbacks using onHVX().add(callback).
     *
     * @note It is possible to unregister callbacks using onHVX().detach(callback).
     */
    HVXCallbackChain_t& onHVX() {
        return onHVXCallbackChain;
    }

public:
    /**
     * Reset the state of the GattClient instance.
     *
     * Prior to any state modification, shutdown event handlers are notified
     * that the GattClient instance is about to be shut down. Then, running
     * procedures end. Finally, the state of the instance is reset.
     *
     * @par implementation note
     *
     * This function is meant to be overridden in the platform-specific
     * subclass. Nevertheless, the subclass only resets its
     * state and not the data held in GattClient members. This is achieved
     * by a call to GattClient::reset() from the subclass' reset()
     * implementation.
     *
     * @return BLE_ERROR_NONE on success.
     */
    ble_error_t reset(void);

protected:

    /* --- Abstract calls to override --- */

    /* Derived implementation must call the base class implementation */
    ble_error_t reset_(void);

    ble_error_t discoverServices_(
        ble::connection_handle_t connectionHandle,
        ServiceDiscovery::ServiceCallback_t callback,
        GattAttribute::Handle_t startHandle,
        GattAttribute::Handle_t endHandle
    );

    ble_error_t launchServiceDiscovery_(
        ble::connection_handle_t connectionHandle,
        ServiceDiscovery::ServiceCallback_t sc,
        ServiceDiscovery::CharacteristicCallback_t cc,
        const UUID &matchingServiceUUID,
        const UUID &matchingCharacteristicUUIDIn
    );

    bool isServiceDiscoveryActive_(void) const;

    void terminateServiceDiscovery_(void);

    ble_error_t negotiateAttMtu_(ble::connection_handle_t connection);

    ble_error_t read_(
        ble::connection_handle_t connHandle,
        GattAttribute::Handle_t attributeHandle,
        uint16_t offset
    ) const;

    ble_error_t write_(
        GattClient::WriteOp_t cmd,
        ble::connection_handle_t connHandle,
        GattAttribute::Handle_t attributeHandle,
        size_t length,
        const uint8_t *value
    ) const;

    void onServiceDiscoveryTermination_(
        ServiceDiscovery::TerminationCallback_t callback
    );

    ble_error_t discoverCharacteristicDescriptors_(
        const DiscoveredCharacteristic& characteristic,
        const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
        const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback
    );

    bool isCharacteristicDescriptorDiscoveryActive_(
        const DiscoveredCharacteristic& characteristic
    ) const;

    void terminateCharacteristicDescriptorDiscovery_(
        const DiscoveredCharacteristic& characteristic
    );

protected:
    GattClient() : eventHandler(NULL)
    {
        /* Empty */
    }

    /* Entry points for the underlying stack to report events back to the user. */
public:
    /**
     * Forward an attribute read event to all registered handlers.
     *
     * @attention This function is meant to be called from the vendor
     * implementation when an attribute read event occurs.
     *
     * @param[in] params Attribute read event to pass to the registered handlers.
     */
    void processReadResponse(const GattReadCallbackParams *params)
    {
        onDataReadCallbackChain(params);
    }

    /**
     * Forward an attribute written event to all registered handlers.
     *
     * @attention This function is meant to be called from the vendor
     * implementation when an attribute written event occurs.
     *
     * @param[in] params Attribute written event to pass to the registered
     * handlers.
     */
    void processWriteResponse(const GattWriteCallbackParams *params)
    {
        onDataWriteCallbackChain(params);
    }

    /**
     * Forward a handle value notification or indication event to all registered
     * handlers.
     *
     * @attention This function is meant to be called from the vendor
     * implementation when a notification or indication event is available.
     *
     * @param[in] params Notification or Indication event to pass to the
     * registered handlers.
     */
    void processHVXEvent(const GattHVXCallbackParams *params)
    {
        if (onHVXCallbackChain) {
            onHVXCallbackChain(params);
        }
    }

protected:
    /**
     * Event handler provided by the application.
     */
    EventHandler *eventHandler;

    /**
     * Callchain containing all registered event handlers for data read
     * events.
     */
    ReadCallbackChain_t onDataReadCallbackChain;

    /**
     * Callchain containing all registered event handlers for data write
     * events.
     */
    WriteCallbackChain_t onDataWriteCallbackChain;

    /**
     * Callchain containing all registered event handlers for update
     * events.
     */
    HVXCallbackChain_t onHVXCallbackChain;

    /**
     * Callchain containing all registered event handlers for shutdown
     * events.
     */
    GattClientShutdownCallbackChain_t shutdownCallChain;

private:
    /* Disallow copy and assignment. */
    GattClient(const GattClient &);
    GattClient& operator=(const GattClient &);
};

/**
 * @}
 * @}
 * @}
 */

#if !defined(DOXYGEN_ONLY)
} // namespace interface
} // namespace ble

using ble::impl::GattClient;
#endif

#endif /* ifndef MBED_GATT_CLIENT_H__ */
