blob: 5048a92b1c48f3b9f9a8379c8333f555eb4e9d12 [file] [log] [blame]
/*
*
* Copyright (c) 2020-2021 Project CHIP Authors
*
* 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.
*/
/**
* @file
* Provides an implementation of the BLEManager singleton object
* for mbed platforms.
*/
#include <inttypes.h>
#include <stdint.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>
#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
#include <platform/mbed/BLEManagerImpl.h>
#include <ble/Ble.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/SafeInt.h>
#include <lib/support/logging/CHIPLogging.h>
#include <platform/CommissionableDataProvider.h>
#include <platform/internal/BLEManager.h>
// Show BLE status with LEDs
#define _BLEMGRIMPL_USE_LEDS 0
// mbed-os headers
#include "ble/BLE.h"
#include "ble/Gap.h"
#include "platform/Callback.h"
#include "platform/NonCopyable.h"
#include "platform/Span.h"
#if _BLEMGRIMPL_USE_LEDS
#include "drivers/DigitalOut.h"
#endif
using namespace ::chip;
using namespace ::chip::Ble;
using namespace ::chip::System;
namespace chip {
namespace DeviceLayer {
namespace Internal {
namespace {
const UUID ShortUUID_CHIPoBLEService(0xFFF6);
// RX = BleLayer::CHIP_BLE_CHAR_1_ID
const UUID LongUUID_CHIPoBLEChar_RX("18EE2EF5-263D-4559-959F-4F9C429F9D11");
const ChipBleUUID ChipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
0x9D, 0x11 } };
// TX = BleLayer::CHIP_BLE_CHAR_2_ID
const UUID LongUUID_CHIPoBLEChar_TX("18EE2EF5-263D-4559-959F-4F9C429F9D12");
const ChipBleUUID ChipUUID_CHIPoBLEChar_TX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
0x9D, 0x12 } };
} // namespace
#if _BLEMGRIMPL_USE_LEDS
#include "drivers/DigitalOut.h"
// LED1 -- toggle on every call to ble::BLE::processEvents()
// LED2 -- on when ble::BLE::init() callback completes
// LED3 -- on when advertising
mbed::DigitalOut led1(LED1, 1);
mbed::DigitalOut led2(LED2, 1);
mbed::DigitalOut led3(LED3, 1);
#endif
class ConnectionInfo
{
public:
struct ConnStatus
{
ble::connection_handle_t connHandle;
uint16_t attMtuSize;
};
ConnectionInfo()
{
for (size_t i = 0; i < kMaxConnections; i++)
{
mConnStates[i].connHandle = kInvalidHandle;
mConnStates[i].attMtuSize = 0;
}
}
CHIP_ERROR setStatus(ble::connection_handle_t conn_handle, uint16_t mtu_size)
{
size_t new_i = kMaxConnections;
for (size_t i = 0; i < kMaxConnections; i++)
{
if (mConnStates[i].connHandle == conn_handle)
{
mConnStates[i].attMtuSize = mtu_size;
return CHIP_NO_ERROR;
}
else if (mConnStates[i].connHandle == kInvalidHandle && i < new_i)
{
new_i = i;
}
}
// Handle not found, has to be added.
if (new_i == kMaxConnections)
{
return CHIP_ERROR_NO_MEMORY;
}
mConnStates[new_i].connHandle = conn_handle;
mConnStates[new_i].attMtuSize = mtu_size;
return CHIP_NO_ERROR;
}
CHIP_ERROR clearStatus(ble::connection_handle_t conn_handle)
{
for (size_t i = 0; i < kMaxConnections; i++)
{
if (mConnStates[i].connHandle == conn_handle)
{
mConnStates[i].connHandle = kInvalidHandle;
mConnStates[i].attMtuSize = 0;
return CHIP_NO_ERROR;
}
}
return CHIP_ERROR_INVALID_ARGUMENT;
}
ConnStatus getStatus(ble::connection_handle_t conn_handle) const
{
for (size_t i = 0; i < kMaxConnections; i++)
{
if (mConnStates[i].connHandle == conn_handle)
{
return mConnStates[i];
}
}
return { kInvalidHandle, 0 };
}
uint16_t getMTU(ble::connection_handle_t conn_handle) const { return getStatus(conn_handle).attMtuSize; }
private:
const size_t kMaxConnections = BLE_LAYER_NUM_BLE_ENDPOINTS;
ConnStatus mConnStates[BLE_LAYER_NUM_BLE_ENDPOINTS];
const ble::connection_handle_t kInvalidHandle = 0xf00d;
};
static ConnectionInfo sConnectionInfo;
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
class GapEventHandler : private mbed::NonCopyable<GapEventHandler>, public ble::Gap::EventHandler
{
void onScanRequestReceived(const ble::ScanRequestEvent & event)
{
// Requires enable action from setScanRequestNotification(true).
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
/* Called when advertising starts.
*/
void onAdvertisingStart(const ble::AdvertisingStartEvent & event)
{
#if _BLEMGRIMPL_USE_LEDS
led3 = 0;
#endif
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
BLEManagerImpl & ble_manager = BLEMgrImpl();
ble_manager.mFlags.Set(ble_manager.kFlag_Advertising);
ble_manager.mFlags.Clear(ble_manager.kFlag_AdvertisingRefreshNeeded);
// Post a CHIPoBLEAdvertisingChange(Started) event.
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEAdvertisingChange;
chip_event.CHIPoBLEAdvertisingChange.Result = kActivity_Started;
PlatformMgrImpl().PostEventOrDie(&chip_event);
PlatformMgr().ScheduleWork(ble_manager.DriveBLEState, 0);
}
/* Called when advertising ends.
*
* Advertising ends when the process timeout or if it is stopped by the
* application or if the local device accepts a connection request.
*/
void onAdvertisingEnd(const ble::AdvertisingEndEvent & event)
{
#if _BLEMGRIMPL_USE_LEDS
led3 = 1;
#endif
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
BLEManagerImpl & ble_manager = BLEMgrImpl();
ble_manager.mFlags.Clear(ble_manager.kFlag_Advertising);
// Post a CHIPoBLEAdvertisingChange(Stopped) event.
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEAdvertisingChange;
chip_event.CHIPoBLEAdvertisingChange.Result = kActivity_Stopped;
PlatformMgrImpl().PostEventOrDie(&chip_event);
if (event.isConnected())
{
ble_manager.mFlags.Set(ble_manager.kFlag_AdvertisingRefreshNeeded);
ChipLogDetail(DeviceLayer, "Restarting advertising to allow more connections.");
}
PlatformMgr().ScheduleWork(ble_manager.DriveBLEState, 0);
}
/* Called when connection attempt ends or an advertising device has been
* connected.
*/
void onConnectionComplete(const ble::ConnectionCompleteEvent & event)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
ble_error_t mbed_err = event.getStatus();
BLEManagerImpl & ble_manager = BLEMgrImpl();
if (mbed_err == BLE_ERROR_NONE)
{
const ble::address_t & peer_addr = event.getPeerAddress();
ChipLogProgress(DeviceLayer, "BLE connection established with %02hhX:%02hhX:%02hhX:%02hhX:%02hhX:%02hhX", peer_addr[5],
peer_addr[4], peer_addr[3], peer_addr[2], peer_addr[1], peer_addr[0]);
ble_manager.mGAPConns++;
CHIP_ERROR err = sConnectionInfo.setStatus(event.getConnectionHandle(), BLE_GATT_MTU_SIZE_DEFAULT);
if (err != CHIP_NO_ERROR)
{
ChipLogError(DeviceLayer, "Unable to store connection status, error: %s ", ErrorStr(err));
}
}
else
{
ChipLogError(DeviceLayer, "BLE connection failed, mbed-os error: %d", mbed_err);
}
ChipLogProgress(DeviceLayer, "Current number of connections: %u/%d", ble_manager.NumConnections(),
ble_manager.kMaxConnections);
// The connection established event is propagated when the client has subscribed to
// the TX characteristic.
}
void onUpdateConnectionParametersRequest(const ble::UpdateConnectionParametersRequestEvent & event)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
void onConnectionParametersUpdateComplete(const ble::ConnectionParametersUpdateCompleteEvent & event)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
void onReadPhy(ble_error_t status, ble::connection_handle_t connectionHandle, ble::phy_t txPhy, ble::phy_t rxPhy)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
void onPhyUpdateComplete(ble_error_t status, ble::connection_handle_t connectionHandle, ble::phy_t txPhy, ble::phy_t rxPhy)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
/* Called when a connection has been disconnected.
*/
void onDisconnectionComplete(const ble::DisconnectionCompleteEvent & event)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
const ble::disconnection_reason_t & reason = event.getReason();
BLEManagerImpl & ble_manager = BLEMgrImpl();
if (ble_manager.NumConnections())
{
ble_manager.mGAPConns--;
}
CHIP_ERROR err = sConnectionInfo.clearStatus(event.getConnectionHandle());
if (err != CHIP_NO_ERROR)
{
ChipLogError(DeviceLayer, "Unable to clear connection status, error: %s ", ErrorStr(err));
}
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEConnectionError;
chip_event.CHIPoBLEConnectionError.ConId = event.getConnectionHandle();
switch (reason.value())
{
case ble::disconnection_reason_t::REMOTE_USER_TERMINATED_CONNECTION:
chip_event.CHIPoBLEConnectionError.Reason = BLE_ERROR_REMOTE_DEVICE_DISCONNECTED;
break;
case ble::disconnection_reason_t::LOCAL_HOST_TERMINATED_CONNECTION:
chip_event.CHIPoBLEConnectionError.Reason = BLE_ERROR_APP_CLOSED_CONNECTION;
break;
default:
chip_event.CHIPoBLEConnectionError.Reason = BLE_ERROR_CHIPOBLE_PROTOCOL_ABORT;
break;
}
PlatformMgrImpl().PostEventOrDie(&chip_event);
ChipLogProgress(DeviceLayer, "BLE connection terminated, mbed-os reason: %d", reason.value());
ChipLogProgress(DeviceLayer, "Current number of connections: %u/%d", ble_manager.NumConnections(),
ble_manager.kMaxConnections);
// Force a reconfiguration of advertising in case we switched to non-connectable mode when
// the BLE connection was established.
ble_manager.mFlags.Set(ble_manager.kFlag_AdvertisingRefreshNeeded);
PlatformMgr().ScheduleWork(ble_manager.DriveBLEState, 0);
}
void onDataLengthChange(ble::connection_handle_t connectionHandle, uint16_t txSize, uint16_t rxSize)
{
ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__);
}
void onPrivacyEnabled() { ChipLogDetail(DeviceLayer, "GAP %s", __FUNCTION__); }
};
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
struct CHIPService : public ble::GattServer::EventHandler
{
CHIPService() {}
CHIPService(const CHIPService &) = delete;
CHIPService & operator=(const CHIPService &) = delete;
CHIP_ERROR init(ble::BLE & ble_interface)
{
ChipLogDetail(DeviceLayer, "GATT %s", __FUNCTION__);
if (mCHIPoBLEChar_RX != nullptr || mCHIPoBLEChar_TX != nullptr)
{
return CHIP_NO_ERROR;
}
mCHIPoBLEChar_RX = new GattCharacteristic(LongUUID_CHIPoBLEChar_RX, nullptr, 0, BLE_GATT_MTU_SIZE_DEFAULT,
GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE |
GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
mCHIPoBLEChar_TX = new GattCharacteristic(LongUUID_CHIPoBLEChar_TX, nullptr, 0, BLE_GATT_MTU_SIZE_DEFAULT,
GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY);
// Setup callback
mCHIPoBLEChar_RX->setWriteAuthorizationCallback(this, &CHIPService::onWriteAuth);
GattCharacteristic * chipoble_gatt_characteristics[] = { mCHIPoBLEChar_RX, mCHIPoBLEChar_TX };
auto num_characteristics = sizeof chipoble_gatt_characteristics / sizeof chipoble_gatt_characteristics[0];
GattService chipoble_gatt_service(ShortUUID_CHIPoBLEService, chipoble_gatt_characteristics, num_characteristics);
auto mbed_err = ble_interface.gattServer().addService(chipoble_gatt_service);
if (mbed_err != BLE_ERROR_NONE)
{
ChipLogError(DeviceLayer, "Unable to add GATT service, mbed-os err: %d", mbed_err);
return CHIP_ERROR_INTERNAL;
}
// Store the attribute handles in the class so they are reused in
// callbacks to discriminate events.
mRxHandle = mCHIPoBLEChar_RX->getValueHandle();
mTxHandle = mCHIPoBLEChar_TX->getValueHandle();
// There is a single descriptor in the characteristic, CCCD is at index 0
mTxCCCDHandle = mCHIPoBLEChar_TX->getDescriptor(0)->getHandle();
ChipLogDetail(DeviceLayer, "char handles: rx=%d, tx=%d, cccd=%d", mRxHandle, mTxHandle, mTxCCCDHandle);
ble_interface.gattServer().setEventHandler(this);
return CHIP_NO_ERROR;
}
// Write authorization callback
void onWriteAuth(GattWriteAuthCallbackParams * params)
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params->connHandle, params->handle);
if (params->handle == mRxHandle)
{
ChipLogDetail(DeviceLayer, "Received BLE packet on RX");
// Allocate a buffer, copy the data. They will be passed into the event
auto buf = System::PacketBufferHandle::NewWithData(params->data, params->len);
if (buf.IsNull())
{
params->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_WRITE_REQUEST_REJECTED;
ChipLogError(DeviceLayer, "Dropping packet, not enough memory");
return;
}
params->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEWriteReceived;
chip_event.CHIPoBLEWriteReceived.ConId = params->connHandle;
chip_event.CHIPoBLEWriteReceived.Data = std::move(buf).UnsafeRelease();
PlatformMgrImpl().PostEventOrDie(&chip_event);
}
else
{
params->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INVALID_HANDLE;
}
}
// overrides of GattServerEvent Handler
void onAttMtuChange(ble::connection_handle_t connectionHandle, uint16_t attMtuSize) override
{
ChipLogDetail(DeviceLayer, "GATT %s", __FUNCTION__);
CHIP_ERROR err = sConnectionInfo.setStatus(connectionHandle, attMtuSize);
if (err != CHIP_NO_ERROR)
{
ChipLogError(DeviceLayer, "Unable to store connection status, error: %s ", ErrorStr(err));
}
}
void onDataSent(const GattDataSentCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.attHandle);
// Note: This is applicable to both notification and indication: If a
// notification is sent then onDataSent is called as soon as the data
// has been pushed into the Bluetooth controller. For indication, onDataSent
// is called when the confirmation has been received.
onConfirmationReceived(params);
}
void onDataWritten(const GattWriteCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.handle);
}
void onDataRead(const GattReadCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.handle);
}
void onShutdown(const ble::GattServer & server) override { ChipLogDetail(DeviceLayer, "GATT %s", __FUNCTION__); }
void onUpdatesEnabled(const GattUpdatesEnabledCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.attHandle);
if (params.attHandle == mTxCCCDHandle)
{
ChipLogDetail(DeviceLayer, "Updates enabled on TX CCCD");
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLESubscribe;
chip_event.CHIPoBLESubscribe.ConId = params.connHandle;
PlatformMgrImpl().PostEventOrDie(&chip_event);
}
}
void onUpdatesDisabled(const GattUpdatesDisabledCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.attHandle);
if (params.attHandle == mTxCCCDHandle)
{
ChipLogDetail(DeviceLayer, "Updates disabled on TX CCCD");
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEUnsubscribe;
chip_event.CHIPoBLEUnsubscribe.ConId = params.connHandle;
PlatformMgrImpl().PostEventOrDie(&chip_event);
}
}
void onConfirmationReceived(const GattConfirmationReceivedCallbackParams & params) override
{
ChipLogDetail(DeviceLayer, "GATT %s, connHandle=%d, attHandle=%d", __FUNCTION__, params.connHandle, params.attHandle);
if (params.attHandle == mTxHandle)
{
ChipLogDetail(DeviceLayer, "Confirmation received for TX transfer");
ChipDeviceEvent chip_event;
chip_event.Type = DeviceEventType::kCHIPoBLEIndicateConfirm;
chip_event.CHIPoBLEIndicateConfirm.ConId = params.connHandle;
PlatformMgrImpl().PostEventOrDie(&chip_event);
}
}
ble::attribute_handle_t getTxHandle() const { return mTxHandle; }
ble::attribute_handle_t getTxCCCDHandle() const { return mTxCCCDHandle; }
ble::attribute_handle_t getRxHandle() const { return mRxHandle; }
GattCharacteristic * mCHIPoBLEChar_RX = nullptr;
GattCharacteristic * mCHIPoBLEChar_TX = nullptr;
ble::attribute_handle_t mRxHandle = 0;
ble::attribute_handle_t mTxCCCDHandle = 0;
ble::attribute_handle_t mTxHandle = 0;
};
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
class SecurityManagerEventHandler : private mbed::NonCopyable<SecurityManagerEventHandler>,
public ble::SecurityManager::EventHandler
{
void pairingRequest(ble::connection_handle_t connectionHandle) override
{
ChipLogDetail(DeviceLayer, "SM %s, connHandle=%d", __FUNCTION__, connectionHandle);
ble::SecurityManager & security_mgr = ble::BLE::Instance().securityManager();
auto mbed_err = security_mgr.acceptPairingRequest(connectionHandle);
if (mbed_err == BLE_ERROR_NONE)
{
ChipLogProgress(DeviceLayer, "Pairing request authorized.");
}
else
{
ChipLogError(DeviceLayer, "Pairing request not authorized, mbed-os err: %d", mbed_err);
}
}
void pairingResult(ble::connection_handle_t connectionHandle, SecurityManager::SecurityCompletionStatus_t result) override
{
ChipLogDetail(DeviceLayer, "SM %s, connHandle=%d", __FUNCTION__, connectionHandle);
if (result == SecurityManager::SEC_STATUS_SUCCESS)
{
ChipLogProgress(DeviceLayer, "Pairing successful.");
}
else
{
ChipLogError(DeviceLayer, "Pairing failed, status: 0x%X.", result);
}
}
void linkEncryptionResult(ble::connection_handle_t connectionHandle, ble::link_encryption_t result) override
{
ChipLogDetail(DeviceLayer, "SM %s, connHandle=%d", __FUNCTION__, connectionHandle);
if (result == ble::link_encryption_t::NOT_ENCRYPTED)
{
ChipLogDetail(DeviceLayer, "Link NOT_ENCRYPTED.");
}
else if (result == ble::link_encryption_t::ENCRYPTION_IN_PROGRESS)
{
ChipLogDetail(DeviceLayer, "Link ENCRYPTION_IN_PROGRESS.");
}
else if (result == ble::link_encryption_t::ENCRYPTED)
{
ChipLogDetail(DeviceLayer, "Link ENCRYPTED.");
}
else if (result == ble::link_encryption_t::ENCRYPTED_WITH_MITM)
{
ChipLogDetail(DeviceLayer, "Link ENCRYPTED_WITH_MITM.");
}
else if (result == ble::link_encryption_t::ENCRYPTED_WITH_SC_AND_MITM)
{
ChipLogDetail(DeviceLayer, "Link ENCRYPTED_WITH_SC_AND_MITM.");
}
else
{
ChipLogDetail(DeviceLayer, "Link encryption status UNKNOWN.");
}
}
};
BLEManagerImpl BLEManagerImpl::sInstance;
static GapEventHandler sMbedGapEventHandler;
static CHIPService sCHIPService;
static SecurityManagerEventHandler sSecurityManagerEventHandler;
/* Initialize the mbed-os BLE subsystem. Register the BLE event processing
* callback to the system event queue. Register the BLE initialization complete
* callback that handles the rest of the setup commands. Register the BLE GAP
* event handler.
*/
CHIP_ERROR BLEManagerImpl::_Init()
{
ble_error_t mbed_err = BLE_ERROR_NONE;
mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Enabled;
mFlags = BitFlags<Flags>(CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART ? kFlag_AdvertisingEnabled : 0);
mGAPConns = 0;
if (!mInitialized)
{
ble::BLE & ble_interface = ble::BLE::Instance();
ble_interface.gap().setEventHandler(&sMbedGapEventHandler);
ReturnErrorOnFailure(sCHIPService.init(ble_interface));
ble_interface.onEventsToProcess(FunctionPointerWithContext<ble::BLE::OnEventsToProcessCallbackContext *>{
[](ble::BLE::OnEventsToProcessCallbackContext * context) { PlatformMgr().ScheduleWork(DoBLEProcessing, 0); } });
mbed_err = ble_interface.init([](ble::BLE::InitializationCompleteCallbackContext * context) {
BLEMgrImpl().HandleInitComplete(context->error == BLE_ERROR_NONE);
});
VerifyOrReturnError(mbed_err == BLE_ERROR_NONE, CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
mInitialized = true;
}
return CHIP_NO_ERROR;
}
/* Process all the events from the mbed-os BLE subsystem.
*/
void BLEManagerImpl::DoBLEProcessing(intptr_t arg)
{
#if _BLEMGRIMPL_USE_LEDS
led1 = !led1;
#endif
ble::BLE::Instance().processEvents();
}
/* This is the mbed-os BLE subsystem init complete callback. Initialize the
* BLELayer and update the state based on the flags.
*/
void BLEManagerImpl::HandleInitComplete(bool no_error)
{
CHIP_ERROR err = CHIP_NO_ERROR;
ble_error_t mbed_err = BLE_ERROR_NONE;
ble::Gap & gap = ble::BLE::Instance().gap();
ble::SecurityManager & security_mgr = ble::BLE::Instance().securityManager();
ble::own_address_type_t addr_type;
ble::address_t addr;
VerifyOrExit(no_error, err = CHIP_ERROR_INTERNAL);
gap.getAddress(addr_type, addr);
ChipLogDetail(DeviceLayer, "Device address: %02X:%02X:%02X:%02X:%02X:%02X", addr[5], addr[4], addr[3], addr[2], addr[1],
addr[0]);
mbed_err = security_mgr.init(
/*bool enableBonding */ false,
/*bool requireMITM */ true,
/*SecurityIOCapabilities_t iocaps*/ SecurityManager::IO_CAPS_NONE,
/*const Passkey_t passkey */ nullptr,
/*bool signing */ true,
/*const char *dbFilepath */ nullptr);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
mbed_err = security_mgr.setPairingRequestAuthorisation(true);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
security_mgr.setSecurityManagerEventHandler(&sSecurityManagerEventHandler);
err = BleLayer::Init(this, this, &DeviceLayer::SystemLayer());
SuccessOrExit(err);
PlatformMgr().ScheduleWork(DriveBLEState, 0);
#if _BLEMGRIMPL_USE_LEDS
led2 = 0;
#endif
exit:
if (err != CHIP_NO_ERROR)
{
ChipLogError(DeviceLayer, "BLEManager init error: %s ", ErrorStr(err));
ChipLogError(DeviceLayer, "Disabling CHIPoBLE service.");
mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Disabled;
mInitialized = false;
PlatformMgr().ScheduleWork(DriveBLEState, 0);
}
}
void BLEManagerImpl::DriveBLEState(intptr_t arg)
{
BLEMgrImpl().DriveBLEState();
}
/* Update the advertising state based on the flags.
*/
void BLEManagerImpl::DriveBLEState()
{
CHIP_ERROR err = CHIP_NO_ERROR;
// Perform any initialization actions that must occur after the CHIP task is running.
if (!mFlags.Has(kFlag_AsyncInitCompleted))
{
mFlags.Set(kFlag_AsyncInitCompleted);
}
// If the application has enabled CHIPoBLE and BLE advertising...
if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled &&
mFlags.Has(kFlag_AdvertisingEnabled)
#if CHIP_DEVICE_CONFIG_CHIPOBLE_SINGLE_CONNECTION
// and no connections are active...
&& (_NumConnections() == 0)
#endif
)
{
// Start/re-start advertising if not already advertising, or if the
// advertising state needs to be refreshed.
if (!mFlags.Has(kFlag_Advertising) || mFlags.Has(kFlag_AdvertisingRefreshNeeded))
{
err = StartAdvertising();
SuccessOrExit(err);
}
}
// Otherwise, stop advertising if currently active.
else
{
err = StopAdvertising();
SuccessOrExit(err);
}
exit:
if (err != CHIP_NO_ERROR)
{
ChipLogError(DeviceLayer, "Disabling CHIPoBLE service due to error: %s", ErrorStr(err));
mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Disabled;
}
}
CHIP_ERROR BLEManagerImpl::_SetAdvertisingMode(BLEAdvertisingMode mode)
{
switch (mode)
{
case BLEAdvertisingMode::kFastAdvertising:
mFlags.Set(Flags::kFlag_FastAdvertisingEnabled, true);
break;
case BLEAdvertisingMode::kSlowAdvertising:
mFlags.Set(Flags::kFlag_AdvertisingEnabled, false);
break;
default:
return CHIP_ERROR_INVALID_ARGUMENT;
}
mFlags.Set(Flags::kFlag_AdvertisingRefreshNeeded);
PlatformMgr().ScheduleWork(DriveBLEState, 0);
return CHIP_NO_ERROR;
}
/* Build the advertising data and start advertising.
*/
CHIP_ERROR BLEManagerImpl::StartAdvertising(void)
{
CHIP_ERROR err = CHIP_NO_ERROR;
ble_error_t mbed_err = BLE_ERROR_NONE;
ble::Gap & gap = ble::BLE::Instance().gap();
ble::AdvertisingDataBuilder adv_data_builder(mAdvertisingDataBuffer);
ChipBLEDeviceIdentificationInfo dev_id_info;
// Advertise CONNECTABLE if we haven't reached the maximum number of connections.
uint16_t num_conns = _NumConnections();
bool connectable = (num_conns < kMaxConnections);
ble::advertising_type_t adv_type =
connectable ? ble::advertising_type_t::CONNECTABLE_UNDIRECTED : ble::advertising_type_t::SCANNABLE_UNDIRECTED;
// Advertise in fast mode if not fully provisioned and there are no CHIPoBLE connections, or
// if the application has expressly requested fast advertising.
ble::adv_interval_t adv_interval = (num_conns == 0 && !ConfigurationMgr().IsFullyProvisioned())
? ble::adv_interval_t(CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MAX)
: ble::adv_interval_t(CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX);
// minInterval and maxInterval are equal for CHIP.
ble::AdvertisingParameters adv_params(adv_type, adv_interval, adv_interval);
// Restart advertising if already active.
if (gap.isAdvertisingActive(ble::LEGACY_ADVERTISING_HANDLE))
{
mbed_err = gap.stopAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
ChipLogDetail(DeviceLayer, "Advertising already active. Restarting.");
}
mbed_err = gap.setAdvertisingParameters(ble::LEGACY_ADVERTISING_HANDLE, adv_params);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
mbed_err =
adv_data_builder.setFlags(ble::adv_data_flags_t::BREDR_NOT_SUPPORTED | ble::adv_data_flags_t::LE_GENERAL_DISCOVERABLE);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
if (!mFlags.Has(kFlag_UseCustomDeviceName))
{
uint16_t discriminator;
SuccessOrExit(err = GetCommissionableDataProvider()->GetSetupDiscriminator(discriminator));
memset(mDeviceName, 0, kMaxDeviceNameLength);
snprintf(mDeviceName, kMaxDeviceNameLength, "%s%04u", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, discriminator);
}
mbed_err = adv_data_builder.setName(mDeviceName);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
dev_id_info.Init();
SuccessOrExit(err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(dev_id_info));
mbed_err = adv_data_builder.setServiceData(
ShortUUID_CHIPoBLEService, mbed::make_Span<const uint8_t>(reinterpret_cast<uint8_t *>(&dev_id_info), sizeof dev_id_info));
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
mbed_err = gap.setAdvertisingPayload(ble::LEGACY_ADVERTISING_HANDLE, adv_data_builder.getAdvertisingData());
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
adv_data_builder.clear();
adv_data_builder.setLocalServiceList(mbed::make_Span<const UUID>(&ShortUUID_CHIPoBLEService, 1));
mbed_err = gap.setAdvertisingScanResponse(ble::LEGACY_ADVERTISING_HANDLE, adv_data_builder.getAdvertisingData());
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
mbed_err = gap.startAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
ChipLogDetail(DeviceLayer, "Advertising started, type: 0x%x (%sconnectable), interval: [%lu:%lu] ms, device name: %s)",
adv_params.getType().value(), connectable ? "" : "non-", adv_params.getMinPrimaryInterval().valueInMs(),
adv_params.getMaxPrimaryInterval().valueInMs(), mDeviceName);
exit:
if (mbed_err != BLE_ERROR_NONE)
{
ChipLogError(DeviceLayer, "StartAdvertising mbed-os error: %d", mbed_err);
}
return err;
}
CHIP_ERROR BLEManagerImpl::StopAdvertising(void)
{
CHIP_ERROR err = CHIP_NO_ERROR;
ble_error_t mbed_err = BLE_ERROR_NONE;
ble::Gap & gap = ble::BLE::Instance().gap();
if (!gap.isAdvertisingActive(ble::LEGACY_ADVERTISING_HANDLE))
{
ChipLogDetail(DeviceLayer, "No need to stop. Advertising inactive.");
return err;
}
mbed_err = gap.stopAdvertising(ble::LEGACY_ADVERTISING_HANDLE);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
exit:
if (mbed_err != BLE_ERROR_NONE)
{
ChipLogError(DeviceLayer, "StopAdvertising mbed-os error: %d", mbed_err);
}
return err;
}
CHIP_ERROR BLEManagerImpl::_SetAdvertisingEnabled(bool val)
{
CHIP_ERROR err = CHIP_NO_ERROR;
VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);
if (mFlags.Has(kFlag_AdvertisingEnabled) != val)
{
ChipLogDetail(DeviceLayer, "SetAdvertisingEnabled(%s)", val ? "true" : "false");
mFlags.Set(kFlag_AdvertisingEnabled, val);
PlatformMgr().ScheduleWork(DriveBLEState, 0);
}
exit:
return err;
}
CHIP_ERROR BLEManagerImpl::_SetFastAdvertisingEnabled(bool val)
{
CHIP_ERROR err = CHIP_NO_ERROR;
VerifyOrExit(mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);
if (mFlags.Has(kFlag_FastAdvertisingEnabled) != val)
{
ChipLogDetail(DeviceLayer, "SetFastAdvertisingEnabled(%s)", val ? "true" : "false");
mFlags.Set(kFlag_FastAdvertisingEnabled, val);
PlatformMgr().ScheduleWork(DriveBLEState, 0);
}
exit:
return err;
}
CHIP_ERROR BLEManagerImpl::_GetDeviceName(char * buf, size_t bufSize)
{
CHIP_ERROR err = CHIP_NO_ERROR;
VerifyOrExit(strlen(mDeviceName) < bufSize, err = CHIP_ERROR_BUFFER_TOO_SMALL);
strcpy(buf, mDeviceName);
exit:
return err;
}
CHIP_ERROR BLEManagerImpl::_SetDeviceName(const char * deviceName)
{
CHIP_ERROR err = CHIP_NO_ERROR;
VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);
if (deviceName != nullptr && deviceName[0] != '\0')
{
VerifyOrExit(strlen(deviceName) < kMaxDeviceNameLength, err = CHIP_ERROR_INVALID_ARGUMENT);
strcpy(mDeviceName, deviceName);
mFlags.Set(kFlag_UseCustomDeviceName);
ChipLogDetail(DeviceLayer, "Device name set to: %s", deviceName);
}
else
{
mDeviceName[0] = '\0';
mFlags.Clear(kFlag_UseCustomDeviceName);
}
exit:
return err;
}
uint16_t BLEManagerImpl::_NumConnections(void)
{
return mGAPConns;
}
void BLEManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
{
switch (event->Type)
{
case DeviceEventType::kCHIPoBLESubscribe: {
ChipDeviceEvent connEstEvent;
ChipLogDetail(DeviceLayer, "_OnPlatformEvent kCHIPoBLESubscribe");
HandleSubscribeReceived(event->CHIPoBLESubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
connEstEvent.Type = DeviceEventType::kCHIPoBLEConnectionEstablished;
PlatformMgrImpl().PostEventOrDie(&connEstEvent);
}
break;
case DeviceEventType::kCHIPoBLEUnsubscribe: {
ChipLogDetail(DeviceLayer, "_OnPlatformEvent kCHIPoBLEUnsubscribe");
HandleUnsubscribeReceived(event->CHIPoBLEUnsubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
}
break;
case DeviceEventType::kCHIPoBLEWriteReceived: {
ChipLogDetail(DeviceLayer, "_OnPlatformEvent kCHIPoBLEWriteReceived");
HandleWriteReceived(event->CHIPoBLEWriteReceived.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_RX,
PacketBufferHandle::Adopt(event->CHIPoBLEWriteReceived.Data));
}
break;
case DeviceEventType::kCHIPoBLEConnectionError: {
ChipLogDetail(DeviceLayer, "_OnPlatformEvent kCHIPoBLEConnectionError");
HandleConnectionError(event->CHIPoBLEConnectionError.ConId, event->CHIPoBLEConnectionError.Reason);
}
break;
case DeviceEventType::kCHIPoBLEIndicateConfirm: {
ChipLogDetail(DeviceLayer, "_OnPlatformEvent kCHIPoBLEIndicateConfirm");
HandleIndicationConfirmation(event->CHIPoBLEIndicateConfirm.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
}
break;
default:
ChipLogDetail(DeviceLayer, "_OnPlatformEvent default: event->Type = 0x%x", event->Type);
break;
}
}
void BLEManagerImpl::NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId)
{
// no-op
}
bool BLEManagerImpl::SubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
ChipLogError(DeviceLayer, "%s: NOT IMPLEMENTED", __PRETTY_FUNCTION__);
return true;
}
bool BLEManagerImpl::UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
ChipLogError(DeviceLayer, "%s: NOT IMPLEMENTED", __PRETTY_FUNCTION__);
return true;
}
bool BLEManagerImpl::CloseConnection(BLE_CONNECTION_OBJECT conId)
{
ChipLogProgress(DeviceLayer, "Closing BLE GATT connection, connHandle=%d", conId);
ble::Gap & gap = ble::BLE::Instance().gap();
ble_error_t mbed_err = gap.disconnect(conId, ble::local_disconnection_reason_t::USER_TERMINATION);
return mbed_err == BLE_ERROR_NONE;
}
uint16_t BLEManagerImpl::GetMTU(BLE_CONNECTION_OBJECT conId) const
{
return sConnectionInfo.getMTU(conId);
}
bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
PacketBufferHandle pBuf)
{
ChipLogDetail(DeviceLayer, "BlePlatformDelegate %s", __FUNCTION__);
CHIP_ERROR err = CHIP_NO_ERROR;
ble_error_t mbed_err = BLE_ERROR_NONE;
ble::GattServer & gatt_server = ble::BLE::Instance().gattServer();
ble::attribute_handle_t att_handle;
// For BLE, the buffer is capped at UINT16_MAX.
VerifyOrExit(CanCastTo<uint16_t>(pBuf->DataLength()), err = CHIP_ERROR_MESSAGE_TOO_LONG);
// No need to do anything fancy here. Only 3 handles are used in this impl.
if (UUIDsMatch(charId, &ChipUUID_CHIPoBLEChar_TX))
{
att_handle = sCHIPService.getTxHandle();
}
else if (UUIDsMatch(charId, &ChipUUID_CHIPoBLEChar_RX))
{
// TODO does this make sense?
att_handle = sCHIPService.getRxHandle();
}
else
{
// TODO handle error with chipConnection::SendMessage as described
// in the BlePlatformDelegate.h.
ChipLogError(DeviceLayer, "Send indication failed, invalid charID.");
return false;
}
ChipLogDetail(DeviceLayer,
"Sending indication for CHIPoBLE characteristic "
"(connHandle=%d, attHandle=%d, data_len=%u)",
conId, att_handle, pBuf->DataLength());
mbed_err = gatt_server.write(att_handle, pBuf->Start(), static_cast<uint16_t>(pBuf->DataLength()), false);
VerifyOrExit(mbed_err == BLE_ERROR_NONE, err = CHIP_ERROR(chip::ChipError::Range::kOS, mbed_err));
exit:
if (mbed_err != BLE_ERROR_NONE)
{
ChipLogError(DeviceLayer, "Send indication failed, mbed-os error: %d", mbed_err);
}
return err == CHIP_NO_ERROR;
}
bool BLEManagerImpl::SendWriteRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
PacketBufferHandle pBuf)
{
ChipLogError(DeviceLayer, "%s: NOT IMPLEMENTED", __PRETTY_FUNCTION__);
return true;
}
bool BLEManagerImpl::SendReadRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
PacketBufferHandle pBuf)
{
ChipLogError(DeviceLayer, "%s: NOT IMPLEMENTED", __PRETTY_FUNCTION__);
return true;
}
bool BLEManagerImpl::SendReadResponse(BLE_CONNECTION_OBJECT conId, BLE_READ_REQUEST_CONTEXT requestContext,
const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
ChipLogError(DeviceLayer, "%s: NOT IMPLEMENTED", __PRETTY_FUNCTION__);
return true;
}
} // namespace Internal
} // namespace DeviceLayer
} // namespace chip
#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE