mbed-os/connectivity/FEATURE_BLE/source/GattClient.cpp

/* mbed Microcontroller Library
 * Copyright (c) 2020 ARM Limited
 * SPDX-License-Identifier: Apache-2.0
 * 
 * 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.
 */

#include "ble/GattClient.h"
#include "source/generic/GattClientImpl.h"

namespace ble {

void GattClient::setEventHandler(EventHandler *handler)
{
    impl->setEventHandler(handler);
}

ble_error_t GattClient::launchServiceDiscovery(
    ble::connection_handle_t connectionHandle,
    ServiceDiscovery::ServiceCallback_t sc,
    ServiceDiscovery::CharacteristicCallback_t  cc,
    const UUID &matchingServiceUUID,
    const UUID &matchingCharacteristicUUIDIn
)
{
    return impl->launchServiceDiscovery(
        connectionHandle, sc, cc, matchingServiceUUID, matchingCharacteristicUUIDIn
    );
}

ble_error_t GattClient::discoverServices(
    ble::connection_handle_t connectionHandle,
    ServiceDiscovery::ServiceCallback_t callback,
    const UUID &matchingServiceUUID
)
{
    return impl->discoverServices(connectionHandle, callback, matchingServiceUUID);
}

ble_error_t GattClient::discoverServices(
    ble::connection_handle_t connectionHandle,
    ServiceDiscovery::ServiceCallback_t callback,
    GattAttribute::Handle_t startHandle,
    GattAttribute::Handle_t endHandle
)
{
    return impl->discoverServices(connectionHandle, callback, startHandle, endHandle);
}

bool GattClient::isServiceDiscoveryActive(void) const
{
    return impl->isServiceDiscoveryActive();
}

void GattClient::terminateServiceDiscovery(void)
{
    return impl->terminateServiceDiscovery();
}

ble_error_t GattClient::read(
    ble::connection_handle_t connHandle,
    GattAttribute::Handle_t attributeHandle,
    uint16_t offset
) const
{
    return impl->read(connHandle, attributeHandle, offset);
}

ble_error_t GattClient::write(
    GattClient::WriteOp_t cmd,
    ble::connection_handle_t connHandle,
    GattAttribute::Handle_t attributeHandle,
    size_t length,
    const uint8_t *value
) const
{
    return impl->write(cmd, connHandle, attributeHandle, length, value);
}

/* Event callback handlers. */

void GattClient::onDataRead(ble::ReadCallback_t callback)
{
    return impl->onDataRead(callback);
}

ble::ReadCallbackChain_t& GattClient::onDataRead()
{
    return impl->onDataRead();
}

void GattClient::onDataWritten(ble::WriteCallback_t callback)
{
    impl->onDataWritten(callback);
}

ble::WriteCallbackChain_t& GattClient::onDataWritten()
{
    return impl->onDataWritten();
}

void GattClient::onServiceDiscoveryTermination(
    ServiceDiscovery::TerminationCallback_t callback
)
{
    return impl->onServiceDiscoveryTermination(callback);
}

ble_error_t GattClient::discoverCharacteristicDescriptors(
    const DiscoveredCharacteristic& characteristic,
    const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
    const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback
)
{
    return impl->discoverCharacteristicDescriptors(
        characteristic,
        discoveryCallback,
        terminationCallback
    );
}

bool GattClient::isCharacteristicDescriptorDiscoveryActive(
    const DiscoveredCharacteristic& characteristic
) const
{
    return impl->isCharacteristicDescriptorDiscoveryActive(characteristic);
}

void GattClient::terminateCharacteristicDescriptorDiscovery(
    const DiscoveredCharacteristic& characteristic
)
{
    return impl->terminateCharacteristicDescriptorDiscovery(characteristic);
}

ble_error_t GattClient::negotiateAttMtu(ble::connection_handle_t connection)
{
    return impl->negotiateAttMtu(connection);
}

void GattClient::onHVX(HVXCallback_t callback)
{
    return impl->onHVX(callback);
}


void GattClient::onShutdown(const GattClientShutdownCallback_t& callback)
{
    return impl->onShutdown(callback);
}

GattClient::GattClientShutdownCallbackChain_t& GattClient::onShutdown()
{
    return impl->onShutdown();
}

GattClient::HVXCallbackChain_t& GattClient::onHVX()
{
    return impl->onHVX();
}

ble_error_t GattClient::reset(void)
{
    return impl->reset();
}

void GattClient::processReadResponse(const GattReadCallbackParams *params)
{
    return impl->processReadResponse(params);
}

void GattClient::processWriteResponse(const GattWriteCallbackParams *params)
{
    return impl->processWriteResponse(params);
}

void GattClient::processHVXEvent(const GattHVXCallbackParams *params)
{
    return impl->processHVXEvent(params);
}

} // namespace ble