/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *    All rights reserved.
 *
 *    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 the Beken platforms.
 */

/* this file behaves like a config.h, comes first */
#include <crypto/CHIPCryptoPAL.h>
#include <platform/CommissionableDataProvider.h>
#include <platform/DeviceInstanceInfoProvider.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>
#include <setup_payload/AdditionalDataPayloadGenerator.h>

#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
#include <ble/CHIPBleServiceData.h>
#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
#include <setup_payload/AdditionalDataPayloadGenerator.h>
#endif
#include "stdio.h"
#include "timers.h"
#include <string.h>

// BK7231n BLE related header files
#include "matter_pal.h"

/*******************************************************************************
 * Local data types
 *******************************************************************************/
using namespace ::chip;
using namespace ::chip::Ble;

namespace chip {
namespace DeviceLayer {
namespace Internal {

namespace {

/*******************************************************************************
 * Macros & Constants definitions
 *******************************************************************************/
#ifndef MAX_ADV_DATA_LEN
#define MAX_ADV_DATA_LEN 31
#endif
#define CHIP_ADV_DATA_TYPE_FLAGS 0x01
#define CHIP_ADV_DATA_FLAGS 0x06

/* advertising configuration */
#define CHIP_ADV_SHORT_UUID_LEN (2)

/* FreeRTOS sw timer */
TimerHandle_t bleFastAdvTimer;

enum
{
    DriveBLEExtPerfEvt_DISCONNECT = 0,
};

const ChipBleUUID ChipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
                                                 0x9D, 0x11 } };
const ChipBleUUID ChipUUID_CHIPoBLEChar_TX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F,
                                                 0x9D, 0x12 } };
static const uint8_t _svc_uuid[16]         = { 0xF6, 0xFF, 0, 0, 0x0, 0x0, 0, 0, 0, 0, 0x0, 0x0, 0, 0, 0, 0 };

#define UUID_CHIPoBLECharact_RX                                                                                                    \
    {                                                                                                                              \
        0x11, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18                             \
    }
//#define UUID_CHIPoBLECharact_RX   { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, 0x11
//}
#define ChipUUID_CHIPoBLECharact_TX                                                                                                \
    {                                                                                                                              \
        0x12, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18                             \
    }
//#define ChipUUID_CHIPoBLECharact_TX   { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D,
// 0x12 }
#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
#define UUID_CHIPoBLEChar_C3                                                                                                       \
    {                                                                                                                              \
        0x04, 0x8F, 0x21, 0x83, 0x8A, 0x74, 0x7D, 0xB8, 0xF2, 0x45, 0x72, 0x87, 0x38, 0x02, 0x63, 0x64                             \
    }
#endif
#define BEKEN_ATT_DECL_PRIMARY_SERVICE_128                                                                                         \
    {                                                                                                                              \
        0x00, 0x28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0                                                                       \
    }
#define BEKEN_ATT_DECL_CHARACTERISTIC_128                                                                                          \
    {                                                                                                                              \
        0x03, 0x28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0                                                                       \
    }
#define BEKEN_ATT_DESC_CLIENT_CHAR_CFG_128                                                                                         \
    {                                                                                                                              \
        0x02, 0x29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0                                                                       \
    }

enum
{
    SVR_FFF6_IDX_SVC,
    SVR_FFF6_RX_DECL,
    SVR_FFF6_RX_VALUE,
    SVR_FFF6_TX_DECL,
    SVR_FFF6_TX_VALUE,
#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
    SVR_FFF6_C3_VALUE,
#endif
    SVR_FFF6_TX_CFG,
    SVR_FFF6_MAX,
};

ble_attm_desc_t svr_fff6_att_db[SVR_FFF6_MAX] = {
    //  Service Declaration
    [SVR_FFF6_IDX_SVC] = { BEKEN_ATT_DECL_PRIMARY_SERVICE_128, BK_BLE_PERM_SET(RD, ENABLE), 0, 2 },

    //  Level Characteristic Declaration
    [SVR_FFF6_RX_DECL] = { BEKEN_ATT_DECL_CHARACTERISTIC_128, BK_BLE_PERM_SET(RD, ENABLE), 0, 0 },
    //  Level Characteristic Value  BK_PERM_RIGHT_ENABLE WRITE_REQ_POS  RI_POS  UUID_LEN_POS  BK_PERM_RIGHT_UUID_128
    [SVR_FFF6_RX_VALUE] = { UUID_CHIPoBLECharact_RX, BK_BLE_PERM_SET(WRITE_REQ, ENABLE),
                            BK_BLE_PERM_SET(RI, ENABLE) | BK_BLE_PERM_SET(UUID_LEN, UUID_128), 512 },

    /// RD_POS  NTF_POS
    [SVR_FFF6_TX_DECL] = { BEKEN_ATT_DECL_CHARACTERISTIC_128, BK_BLE_PERM_SET(RD, ENABLE) | BK_BLE_PERM_SET(NTF, ENABLE), 0, 0 },
    ////  UUID_LEN_POS   BK_PERM_RIGHT_UUID_128 RD_POS
    [SVR_FFF6_TX_VALUE] = { ChipUUID_CHIPoBLECharact_TX, BK_BLE_PERM_SET(RD, ENABLE) | BK_BLE_PERM_SET(NTF, ENABLE),
                            BK_BLE_PERM_SET(RI, ENABLE) | BK_BLE_PERM_SET(UUID_LEN, UUID_128), 512 },
#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
    [SVR_FFF6_C3_VALUE] = { UUID_CHIPoBLEChar_C3, BK_BLE_PERM_SET(RD, ENABLE),
                            BK_BLE_PERM_SET(RI, ENABLE) | BK_BLE_PERM_SET(UUID_LEN, UUID_128), 512 },
#endif
    [SVR_FFF6_TX_CFG] = { BEKEN_ATT_DESC_CLIENT_CHAR_CFG_128, BK_BLE_PERM_SET(RD, ENABLE) | BK_BLE_PERM_SET(WRITE_REQ, ENABLE), 0,
                          2 },
};

/// const static uint8_t svr_fff6_att_db_item = SVR_FFF6_MAX;
} // namespace

BLEManagerImpl BLEManagerImpl::sInstance;

int BLEManagerImpl::beken_ble_init(void)
{
    int status;

    struct bk_ble_db_cfg ble_db_cfg;

    ble_db_cfg.att_db      = svr_fff6_att_db;
    ble_db_cfg.att_db_nb   = SVR_FFF6_MAX;
    ble_db_cfg.prf_task_id = 0;
    ble_db_cfg.start_hdl   = 0;
    ble_db_cfg.svc_perm    = BK_BLE_PERM_SET(SVC_UUID_LEN, UUID_16);
    memcpy(&(ble_db_cfg.uuid[0]), &_svc_uuid[0], 16);
    status = bk_ble_create_db(&ble_db_cfg);

    if (status != BK_ERR_BLE_SUCCESS)
    {
        return -1;
    }
    return 0;
}

CHIP_ERROR BLEManagerImpl::_Init()
{
    CHIP_ERROR err;

    // Initialize the CHIP BleLayer.
    err = BleLayer::Init(this, this, &DeviceLayer::SystemLayer());
    SuccessOrExit(err);

    mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Enabled;
    memset(mBleConnections, 0, sizeof(mBleConnections));
    // Check if BLE stack is initialized
    VerifyOrExit(!mFlags.Has(Flags::kAMEBABLEStackInitialized), err = CHIP_ERROR_INCORRECT_STATE);
    bk_ble_set_notice_cb(ble_event_notice);

    // Set related flags
    mFlags.ClearAll().Set(Flags::kAdvertisingEnabled, CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART);
    mFlags.Set(Flags::kAMEBABLEStackInitialized);
    mFlags.Set(Flags::kAdvertisingEnabled, CHIP_DEVICE_CONFIG_CHIPOBLE_ENABLE_ADVERTISING_AUTOSTART ? true : false);
    mFlags.Set(Flags::kFastAdvertisingEnabled);
    mFlags.Set(Flags::kSlowAdvertisingEnabled);
    if (!mFlags.Has(Flags::kBEKENBLEAdvTimer))
    {
        uint32_t bleAdvTimeoutMs = CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME;
        bleFastAdvTimer          = xTimerCreate("", (bleAdvTimeoutMs / 2), pdFALSE, NULL, ble_adv_timer_timeout_handle);
        mFlags.Set(Flags::kBEKENBLEAdvTimer);
    }

    PlatformMgr().ScheduleWork(DriveBLEState, 0);

exit:
    return err;
}

void BLEManagerImpl::HandleTXCharRead(void * param)
{
    CHIPoBLEConState * conState;
    ble_read_req_t * r_req = (ble_read_req_t *) param;
    if (param == NULL)
    {
        ChipLogError(DeviceLayer, "HandleTXCharRead failed: %p", param);
    }
    r_req->length = 0;
}

void BLEManagerImpl::HandleTXCharCCCDRead(void * param)
{
    CHIPoBLEConState * conState;
    ble_read_req_t * r_req = (ble_read_req_t *) param;
    conState               = GetConnectionState(r_req->conn_idx);

    if (param == NULL)
    {
        ChipLogError(DeviceLayer, "HandleTXCharCCCDRead failed");
        return;
    }

    if (conState != NULL)
    {
        r_req->value[0] = conState->subscribed ? 1 : 0;
        r_req->value[1] = 0;
        r_req->length   = 2;
    }
    else
    {
        ChipLogError(DeviceLayer, "conState failed: %p", conState);
        r_req->length = 0;
    }
}

void BLEManagerImpl::HandleTXCharCCCDWrite(int conn_id, int notificationsEnabled, int indicationsEnabled)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    // If the client has requested to enabled indications/notifications
    if (indicationsEnabled || notificationsEnabled)
    {
        // If indications are not already enabled for the connection...
        if (!IsSubscribed(conn_id))
        {
            // Record that indications have been enabled for this connection.
            err = SetSubscribed(conn_id);
            VerifyOrExit(err != CHIP_ERROR_NO_MEMORY, err = CHIP_NO_ERROR);
            SuccessOrExit(err);
        }
    }
    else
    {
        // If indications had previously been enabled for this connection, record that they are no longer enabled.
        UnsetSubscribed(conn_id);
    }

    // Post an event to the Chip queue to process either a CHIPoBLE Subscribe or Unsubscribe based on
    // whether the client is enabling or disabling indications.
    {
        ChipDeviceEvent event;
        event.Type = (indicationsEnabled || notificationsEnabled) ? DeviceEventType::kCHIPoBLESubscribe
                                                                  : DeviceEventType::kCHIPoBLEUnsubscribe;
        event.CHIPoBLESubscribe.ConId = conn_id;
        PlatformMgr().PostEventOrDie(&event);
    }

    ChipLogProgress(DeviceLayer, "CHIPoBLE %s received",
                    (indicationsEnabled || notificationsEnabled) ? "subscribe" : "unsubscribe");

exit:
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "HandleTXCharCCCDWrite() failed: %s", ErrorStr(err));
    }

    return;
}

CHIP_ERROR BLEManagerImpl::HandleTXComplete(int conn_id)
{
    // Post an event to the Chip queue to process the indicate confirmation.
    ChipDeviceEvent event;
    event.Type                          = DeviceEventType::kCHIPoBLEIndicateConfirm;
    event.CHIPoBLEIndicateConfirm.ConId = conn_id;
    PlatformMgr().PostEventOrDie(&event);
    return CHIP_NO_ERROR;
}

uint16_t BLEManagerImpl::_NumConnections(void)
{
    uint16_t numCons = 0;

    for (uint8_t i = 0; i < kMaxConnections; i++)
    {
        if (mBleConnections[i].allocated == 1)
        {
            numCons += 1;
        }
    }

    return numCons;
}

CHIP_ERROR BLEManagerImpl::HandleGAPConnect(uint16_t conn_id)
{
    CHIP_ERROR err = CHIP_NO_ERROR;
    // Track the number of active GAP connections.
    mNumGAPCons++;
    err = SetSubscribed(conn_id);
    VerifyOrExit(err != CHIP_ERROR_NO_MEMORY, err = CHIP_NO_ERROR);
    SuccessOrExit(err);

exit:
    return err;
}

CHIP_ERROR BLEManagerImpl::HandleGAPDisconnect(uint16_t conn_id, uint16_t disc_cause)
{
    // Update the number of GAP connections.
    if (mNumGAPCons > 0)
    {
        mNumGAPCons--;
    }

    if (RemoveConnection(conn_id))
    {
        CHIP_ERROR disconReason;
        switch (disc_cause)
        {
        case 0x13:
        case 0x08:
            disconReason = BLE_ERROR_REMOTE_DEVICE_DISCONNECTED;
            break;
        case 0x16:
            disconReason = BLE_ERROR_APP_CLOSED_CONNECTION;
            break;
        default:
            disconReason = BLE_ERROR_CHIPOBLE_PROTOCOL_ABORT;
            break;
        }
        HandleConnectionError(conn_id, disconReason);
    }

    // Force a reconfiguration of advertising in case we switched to non-connectable mode when
    // the BLE connection was established.
    mFlags.Set(Flags::kAdvertisingRefreshNeeded);
    return CHIP_NO_ERROR;
}

bool BLEManagerImpl::RemoveConnection(uint8_t connectionHandle)
{
    CHIPoBLEConState * bleConnState = GetConnectionState(connectionHandle);
    bool status                     = false;

    if (bleConnState != NULL)
    {
        bleConnState->Reset();
        memset(bleConnState, 0, sizeof(CHIPoBLEConState));
        status = true;
    }
    return status;
}

BLEManagerImpl::CHIPoBLEConState * BLEManagerImpl::GetConnectionState(uint8_t connectionHandle, bool allocate)
{
    uint8_t freeIndex = kMaxConnections;

    for (uint8_t i = 0; i < kMaxConnections; i++)
    {
        if (mBleConnections[i].allocated == 1)
        {
            if (mBleConnections[i].conn_idx == connectionHandle)
            {
                return &mBleConnections[i];
            }
        }

        else if (i < freeIndex)
        {
            freeIndex = i;
        }
    }

    if (allocate)
    {
        if (freeIndex < kMaxConnections)
        {
            mBleConnections[freeIndex].Set(connectionHandle);
            return &mBleConnections[freeIndex];
        }

        ChipLogError(DeviceLayer, "Failed to allocate CHIPoBLEConState");
    }

    return NULL;
}

CHIP_ERROR BLEManagerImpl::_SetCHIPoBLEServiceMode(CHIPoBLEServiceMode val)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    VerifyOrExit(val != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_INVALID_ARGUMENT);
    VerifyOrExit(mServiceMode != ConnectivityManager::kCHIPoBLEServiceMode_NotSupported, err = CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);

    if (val != mServiceMode)
    {
        mServiceMode = val;
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
    }

exit:
    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(Flags::kAdvertisingEnabled) != val)
    {
        mFlags.Set(Flags::kAdvertisingEnabled, val);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
    }

exit:
    return err;
}

CHIP_ERROR BLEManagerImpl::_SetAdvertisingMode(BLEAdvertisingMode mode)
{
    switch (mode)
    {
    case BLEAdvertisingMode::kFastAdvertising:
        mFlags.Set(Flags::kFastAdvertisingEnabled, true);
        break;
    case BLEAdvertisingMode::kSlowAdvertising:
        mFlags.Set(Flags::kFastAdvertisingEnabled, false);
        break;
    default:
        return CHIP_ERROR_INVALID_ARGUMENT;
    }
    mFlags.Set(Flags::kAdvertisingRefreshNeeded);

    PlatformMgr().ScheduleWork(DriveBLEState, 0);

    return CHIP_NO_ERROR;
}

CHIP_ERROR BLEManagerImpl::_GetDeviceName(char * buf, size_t bufSize)
{
    if (strlen(mDeviceName) >= bufSize)
    {
        return CHIP_ERROR_BUFFER_TOO_SMALL;
    }
    strcpy(buf, mDeviceName);
    return CHIP_NO_ERROR;
}

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 != NULL && deviceName[0] != 0)
    {
        VerifyOrExit(strlen(deviceName) >= kMaxDeviceNameLength, err = CHIP_ERROR_INVALID_ARGUMENT);
        strcpy(mDeviceName, deviceName);
        mFlags.Set(Flags::kDeviceNameSet);
        ChipLogProgress(DeviceLayer, "Setting device name to : \"%s\"", deviceName);
    }
    else
    {
        mDeviceName[0] = 0;
        mFlags.Clear(Flags::kDeviceNameSet);
    }

exit:
    return err;
}

void BLEManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
{
    switch (event->Type)
    {
    // Platform specific events
    case DeviceEventType::kCHIPoBLESubscribe:
        HandleSubscribeReceived(event->CHIPoBLESubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
        {
            ChipDeviceEvent connEstEvent;
            connEstEvent.Type = DeviceEventType::kCHIPoBLEConnectionEstablished;
            PlatformMgr().PostEventOrDie(&connEstEvent);
        }
        break;

    case DeviceEventType::kCHIPoBLEUnsubscribe: {
        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEUnsubscribe");
        HandleUnsubscribeReceived(event->CHIPoBLEUnsubscribe.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
    }
    break;

    case DeviceEventType::kCHIPoBLEWriteReceived: {
        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEWriteReceived");
        HandleWriteReceived(event->CHIPoBLEWriteReceived.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_RX,
                            PacketBufferHandle::Adopt(event->CHIPoBLEWriteReceived.Data));
    }
    break;

    case DeviceEventType::kCHIPoBLEConnectionError: {
        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEConnectionError");
        HandleConnectionError(event->CHIPoBLEConnectionError.ConId, event->CHIPoBLEConnectionError.Reason);
    }
    break;

    case DeviceEventType::kCHIPoBLEIndicateConfirm: {
        ChipLogProgress(DeviceLayer, "_OnPlatformEvent kCHIPoBLEIndicateConfirm");
        HandleIndicationConfirmation(event->CHIPoBLEIndicateConfirm.ConId, &CHIP_BLE_SVC_ID, &ChipUUID_CHIPoBLEChar_TX);
    }
    break;

    case DeviceEventType::kServiceProvisioningChange:
    case DeviceEventType::kWiFiConnectivityChange:
        ChipLogProgress(DeviceLayer, "Updating advertising data");
        StartAdvertising();
        break;

    default:
        ChipLogProgress(DeviceLayer, "_OnPlatformEvent default:  event->Type = %d", event->Type);
        break;
    }
}

bool BLEManagerImpl::SubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
    ChipLogProgress(DeviceLayer, "BLEManagerImpl::SubscribeCharacteristic() not supported");
    return false;
}

bool BLEManagerImpl::UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
    ChipLogProgress(DeviceLayer, "BLEManagerImpl::UnsubscribeCharacteristic() not supported");
    return false;
}

bool BLEManagerImpl::CloseConnection(BLE_CONNECTION_OBJECT conId)
{
    CHIP_ERROR err;
    ChipLogProgress(DeviceLayer, "Closing BLE GATT connection (con %u)", conId);
    uint32_t delay_time = 20;
    int ret;

    do
    {
        ret = bk_ble_disconnect(conId, beken_ble_cmd_cb);
        if (BK_ERR_BLE_SUCCESS == ret)
        {
            break;
        }

        rtos_delay_milliseconds(10);
        delay_time--;
    } while (delay_time);
    // Beken Ble close function
    err = MapBLEError(ret);
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "bk_ble_disconnect() failed: %s", ErrorStr(err));
    }

    return false;
}

uint16_t BLEManagerImpl::GetMTU(BLE_CONNECTION_OBJECT conId) const
{
    CHIPoBLEConState * conState = const_cast<BLEManagerImpl *>(this)->GetConnectionState(conId);
    return (conState != NULL) ? conState->mtu : 0;
}

bool BLEManagerImpl::SendWriteRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
                                      PacketBufferHandle pBuf)
{
    ChipLogError(DeviceLayer, "BLEManagerImpl::SendWriteRequest() not supported");
    return false;
}

bool BLEManagerImpl::SendReadRequest(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
                                     PacketBufferHandle pBuf)
{
    ChipLogError(DeviceLayer, "BLEManagerImpl::SendReadRequest() not supported");
    return false;
}

bool BLEManagerImpl::SendReadResponse(BLE_CONNECTION_OBJECT conId, BLE_READ_REQUEST_CONTEXT requestContext,
                                      const ChipBleUUID * svcId, const ChipBleUUID * charId)
{
    ChipLogError(DeviceLayer, "BLEManagerImpl::SendReadResponse() not supported");
    return false;
}

void BLEManagerImpl::NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId)
{
    // Nothing to do
}

bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const ChipBleUUID * svcId, const ChipBleUUID * charId,
                                    PacketBufferHandle data)
{
    CHIP_ERROR err = CHIP_NO_ERROR;
    int ret;

    VerifyOrExit(IsSubscribed(conId), err = CHIP_ERROR_INVALID_ARGUMENT);
    ret = bk_ble_send_noti_value(data->DataLength(), data->Start(), 0, SVR_FFF6_TX_VALUE);
    err = MapBLEError(ret);
exit:
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "BLEManagerImpl::SendIndication() failed: %s", ErrorStr(err));
        return false;
    }

    return true;
}

/*******************************************************************************
 * Private functions
 *******************************************************************************/

CHIP_ERROR BLEManagerImpl::ConfigureAdvertisingData(void)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    // If the device name is not specified, generate a CHIP-standard name based on the bottom digits of the Chip device id.
    uint16_t discriminator;
    SuccessOrExit(err = GetCommissionableDataProvider()->GetSetupDiscriminator(discriminator));

    if (!mFlags.Has(Flags::kDeviceNameSet))
    {
        snprintf(mDeviceName, sizeof(mDeviceName), "%s%04u", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, discriminator);
        mDeviceName[kMaxDeviceNameLength] = 0;
    }

    // Configure the BLE device name.
    sInstance.mFlags.Set(Flags::kDeviceNameDefSet);
    bk_ble_appm_set_dev_name(kMaxDeviceNameLength, (uint8_t *) mDeviceName);
exit:
    return err;
}

CHIP_ERROR BLEManagerImpl::StartAdvertising(void)
{
    ble_err_t bk_err;
    CHIP_ERROR err = CHIP_NO_ERROR;

    ChipLogProgress(DeviceLayer, "StartAdvertising...");
    ChipLogProgress(DeviceLayer, "BLE flag  = %x", mFlags.Raw());
    if ((!mFlags.Has(Flags::kDeviceNameSet)) && (!mFlags.Has(Flags::kDeviceNameDefSet)))
    {
        err = sInstance.ConfigureAdvertisingData();
        SuccessOrExit(err);
    }
    // Post a CHIPoBLEAdvertisingChange(Stopped) event.
    if (mFlags.Has(Flags::kBEKENBLEADVStop))
    {
        bk_ble_delete_advertising(adv_actv_idx, beken_ble_cmd_cb);
        mFlags.Clear(Flags::kBEKENBLEADVStop);
        ChipDeviceEvent advChange;
        advChange.Type                             = DeviceEventType::kCHIPoBLEAdvertisingChange;
        advChange.CHIPoBLEAdvertisingChange.Result = kActivity_Stopped;
        PlatformMgr().PostEventOrDie(&advChange);
        goto exit;
    }
    else if (!mFlags.Has(Flags::kBEKENBLEADVCreate))
    {
        ChipLogProgress(DeviceLayer, "BLE ADVCreate...");
        uint16_t adv_int_min;
        uint16_t adv_int_max;
        ble_adv_param_t adv_param;

        memset(&adv_param, 0, sizeof(adv_param));

        if (mFlags.Has(Flags::kFastAdvertisingEnabled))
        {
            adv_int_min = CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MIN;
            adv_int_max = CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MAX;
            mFlags.Set(Flags::kAdvertisingIsFastADV);
        }
        else
        {
            adv_int_min = CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MIN;
            adv_int_max = CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX;
            mFlags.Clear(Flags::kAdvertisingIsFastADV);
        }

        adv_actv_idx = bk_ble_get_idle_actv_idx_handle();
        if (UNKNOW_ACT_IDX == adv_actv_idx)
        {
            ChipLogError(DeviceLayer, "adv act-idx:%d error", adv_actv_idx);
            return MapBLEError(-1);
        }
        adv_param.chnl_map      = 7;
        adv_param.adv_intv_max  = 160;
        adv_param.adv_intv_min  = 160;
        adv_param.own_addr_type = 0;
        adv_param.adv_type      = 0;
        adv_param.adv_prop      = 3;
        adv_param.prim_phy      = 1;
        // bk_ble_create_advertising(adv_actv_idx, 7, adv_int_min, adv_int_max, beken_ble_cmd_cb);
        bk_err = bk_ble_create_advertising(adv_actv_idx, &adv_param, beken_ble_cmd_cb);
        if (bk_err != BK_OK)
        {
            ChipLogProgress(DeviceLayer, "BLE ADVCreate ret= %x.", bk_err);
        }
        ChipLogProgress(DeviceLayer, "BLE ADVCreate ret= %x. adv_actv_idx = %x", bk_err, adv_actv_idx);
        sInstance.mFlags.Clear(Flags::kAdvertisingRefreshNeeded);
        goto exit;
    }
    else if (!mFlags.Has(Flags::kBEKENBLEADVSetData))
    {
        ChipLogProgress(DeviceLayer, "BLE SetData...");
        ChipBLEDeviceIdentificationInfo deviceIdInfo;
        uint8_t advData[MAX_ADV_DATA_LEN] = { 0 };
        uint8_t index                     = 0;
        /**************** Prepare advertising data *******************************************/
        memset(advData, 0, sizeof(advData));
        advData[index++] = 0x02;                     // length
        advData[index++] = CHIP_ADV_DATA_TYPE_FLAGS; // AD type : flags
        advData[index++] = CHIP_ADV_DATA_FLAGS;      // AD value
        advData[index++] = static_cast<uint8_t>(sizeof(deviceIdInfo) + CHIP_ADV_SHORT_UUID_LEN + 1);
        ;                                                             // length
        advData[index++] = 0x16;                                      // AD type: (Service Data - 16-bit UUID)
        advData[index++] = static_cast<uint8_t>(_svc_uuid[0] & 0xFF); // AD value
        advData[index++] = static_cast<uint8_t>(_svc_uuid[1] & 0xFF); // AD value
        err              = ConfigurationMgr().GetBLEDeviceIdentificationInfo(deviceIdInfo);
        if (err != CHIP_NO_ERROR)
        {
            ChipLogError(DeviceLayer, "GetBLEDeviceIdentificationInfo(): %s", ErrorStr(err));
            ExitNow();
        }

#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
        deviceIdInfo.SetAdditionalDataFlag(true);
#endif
        VerifyOrExit(index + sizeof(deviceIdInfo) <= sizeof(advData), err = CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG);

        memcpy(&advData[index], &deviceIdInfo, sizeof(deviceIdInfo));
        index = static_cast<uint8_t>(index + sizeof(deviceIdInfo));
        bk_ble_set_adv_data(adv_actv_idx, advData, index, beken_ble_cmd_cb);
        goto exit;
    }
    else if (!mFlags.Has(Flags::kBEKENBLEADVSetRsp))
    {
        /// uint8_t advData[MAX_ADV_DATA_LEN]    = { 0 };
        /// bk_ble_set_scan_rsp_data(adv_actv_idx, advData, 0xF, beken_ble_cmd_cb);
        sInstance.mFlags.Set(Flags::kBEKENBLEADVSetRsp);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        goto exit;
    }
    else if (!mFlags.Has(Flags::kBEKENBLEADVStarted))
    {
        ChipLogProgress(DeviceLayer, "BLE Started...");
        bk_ble_start_advertising(adv_actv_idx, 0, beken_ble_cmd_cb);
        goto exit;
    }

    if (mFlags.Has(Flags::kBEKENBLEADVStarted))
    {
        ChipDeviceEvent advChange;
        advChange.Type                             = DeviceEventType::kCHIPoBLEAdvertisingChange;
        advChange.CHIPoBLEAdvertisingChange.Result = kActivity_Started;
        PlatformMgr().PostEventOrDie(&advChange);
    }

exit:
    return err;
}

CHIP_ERROR BLEManagerImpl::StopAdvertising(void)
{
    // Change flag status to the 'not Advertising state'
    if ((mFlags.Has(Flags::kBEKENBLEADVStarted)) && (!mFlags.Has(Flags::kBEKENBLEADVStop)))
    {
        mFlags.Set(Flags::kBEKENBLEADVStop);
        bk_ble_stop_advertising(adv_actv_idx, beken_ble_cmd_cb);
        ChipLogProgress(DeviceLayer, "CHIPoBLE advertising stopping");
        goto exit;
    }

    // Post a CHIPoBLEAdvertisingChange(Stopped) event.
    if (mFlags.Has(Flags::kBEKENBLEADVStop))
    {
        bk_ble_delete_advertising(adv_actv_idx, beken_ble_cmd_cb);
        mFlags.Clear(Flags::kBEKENBLEADVStop);
        ChipDeviceEvent advChange;
        advChange.Type                             = DeviceEventType::kCHIPoBLEAdvertisingChange;
        advChange.CHIPoBLEAdvertisingChange.Result = kActivity_Stopped;
        PlatformMgr().PostEventOrDie(&advChange);
    }
exit:
    return CHIP_NO_ERROR;
}

CHIP_ERROR BLEManagerImpl::MapBLEError(int bleErr)
{
    switch (bleErr)
    {
    case BK_ERR_BLE_SUCCESS:
        return CHIP_NO_ERROR;
    default:
        return CHIP_ERROR_INCORRECT_STATE;
    }
}

void BLEManagerImpl::DriveBLEState(void)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    // Check if BLE stack is initialized
    VerifyOrExit(mFlags.Has(Flags::kAMEBABLEStackInitialized), /* */);
    if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled)
    {
        if (!mFlags.Has(Flags::kBekenBLESGATTSReady))
        {
            beken_ble_init();
            goto exit;
        }
    }

    if ((!mFlags.Has(Flags::kFastAdvertisingEnabled)) && (!mFlags.Has(Flags::kSlowAdvertisingEnabled)))
    {
        mFlags.Clear(Flags::kAdvertisingEnabled);
        mFlags.Clear(Flags::kAdvertisingRefreshNeeded);
    }

    if (mFlags.Has(Flags::kAdvertisingRefreshNeeded))
    {
        if (mFlags.Has(Flags::kBEKENBLEADVStarted))
        {
            err = StopAdvertising();
            SuccessOrExit(err);
            goto exit;
        }
        else if (mFlags.Has(Flags::kBEKENBLEADVStarted))
        {
            bk_ble_delete_advertising(adv_actv_idx, beken_ble_cmd_cb);
            goto exit;
        }
    }

    // Start advertising if needed...
    if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled &&
        ((mFlags.Has(Flags::kAdvertisingEnabled)) || (mFlags.Has(Flags::kAdvertisingRefreshNeeded))))
    {
        // Start/re-start advertising if not already started, or if there is a pending change
        // to the advertising configuration.
        if (!mFlags.Has(Flags::kBEKENBLEADVStarted))
        {
            err = StartAdvertising();
            SuccessOrExit(err);
        }
        else
        {
            mFlags.Clear(Flags::kAdvertisingRefreshNeeded);
        }
    }
    // Otherwise, stop advertising if it is enabled.
    else if ((mFlags.Has(Flags::kBEKENBLEADVStarted)) || (mFlags.Has(Flags::kBEKENBLEADVStop)))
    {
        err = StopAdvertising();
        SuccessOrExit(err);
        ChipLogProgress(DeviceLayer, "Stopped Advertising");
    }

exit:
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "Disabling CHIPoBLE service due to error: %s", ErrorStr(err));
        mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Disabled;
    }
}

void BLEManagerImpl::DriveBLEState(intptr_t arg)
{
    sInstance.DriveBLEState();
}

void BLEManagerImpl::DriveBLEExtPerf(intptr_t arg)
{
    int arg_int = static_cast<int>(arg);
    int event   = arg_int & 0xFFU;
    switch (event)
    {
    case DriveBLEExtPerfEvt_DISCONNECT: {
        uint8_t conn_indx = (arg_int >> 8) & 0xFFU;
        sInstance.CloseConnection(conn_indx);
    }
    break;
    default:
        break;
    }
}

/*******************************************************************************
 * FreeRTOS Task Management Functions
 *******************************************************************************/
void BLEManagerImpl::ble_adv_timer_timeout_handle(TimerHandle_t xTimer)
{
    if (sInstance.mFlags.Has(Flags::kFastAdvertisingEnabled))
    {
        ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop Fast advertisement");

        sInstance.mFlags.Clear(Flags::kFastAdvertisingEnabled);
        // Stop advertising, change interval and restart it;
        sInstance.StopAdvertising();
    }
    else if (sInstance._IsAdvertisingEnabled())
    {
        // Advertisement time expired. Stop advertising
        ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop slow advertisement");
        sInstance.mFlags.Clear(Flags::kSlowAdvertisingEnabled);
        sInstance.StopAdvertising();
    }
}

void BLEManagerImpl::CancelBleAdvTimeoutTimer(void)
{
    if (xTimerIsTimerActive(bleFastAdvTimer))
    {
        if (xTimerStop(bleFastAdvTimer, 0) == pdFAIL)
        {
            ChipLogError(DeviceLayer, "Failed to stop BledAdv timeout timer");
            sInstance.mFlags.Clear(Flags::kBEKENBLEAdvTimerRun);
        }
    }
}

void BLEManagerImpl::StartBleAdvTimeoutTimer(uint32_t aTimeoutInMs)
{
    CancelBleAdvTimeoutTimer();
    // timer is not active, change its period to required value (== restart).
    // FreeRTOS- Block for a maximum of 100 ticks if the change period command
    // cannot immediately be sent to the timer command queue.
    if (xTimerChangePeriod(bleFastAdvTimer, aTimeoutInMs / portTICK_PERIOD_MS, 100) != pdPASS)
    {
        ChipLogError(DeviceLayer, "Failed to start BledAdv timeout timer");
    }
    else
    {
        xTimerStart(bleFastAdvTimer, BEKEN_WAIT_FOREVER);
        sInstance.mFlags.Set(Flags::kBEKENBLEAdvTimerRun);
    }
}

CHIP_ERROR BLEManagerImpl::SetSubscribed(uint16_t conId)
{
    CHIPoBLEConState * bleConnState = GetConnectionState(conId, false);

    if (bleConnState != NULL)
    {
        bleConnState->subscribed = 1;
        return CHIP_NO_ERROR;
    }

    return CHIP_ERROR_NO_MEMORY;
}

bool BLEManagerImpl::UnsetSubscribed(uint16_t conId)
{
    CHIPoBLEConState * bleConnState = GetConnectionState(conId, false);

    if (bleConnState != NULL)
    {
        bleConnState->subscribed = 0;
        return true;
    }

    return false;
}

bool BLEManagerImpl::IsSubscribed(uint16_t conId)
{
    CHIPoBLEConState * bleConnState = GetConnectionState(conId, false);

    if (bleConnState != NULL)
    {
        if (bleConnState->subscribed)
        {
            return true;
        }
    }
    return false;
}

void BLEManagerImpl::HandleRXCharWrite(uint8_t * p_value, uint16_t len, uint8_t conn_id)
{
    CHIP_ERROR err         = CHIP_NO_ERROR;
    PacketBufferHandle buf = System::PacketBufferHandle::New(len, 0);
    memcpy(buf->Start(), p_value, len);
    buf->SetDataLength(len);

    // Post an event to the Chip queue to deliver the data into the Chip stack.
    {
        ChipDeviceEvent event;
        event.Type                        = DeviceEventType::kCHIPoBLEWriteReceived;
        event.CHIPoBLEWriteReceived.ConId = (uint16_t) conn_id;
        event.CHIPoBLEWriteReceived.Data  = std::move(buf).UnsafeRelease();
        PlatformMgr().PostEventOrDie(&event);
    }

    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "HandleRXCharWrite() failed: %s", ErrorStr(err));
    }
}

void BLEManagerImpl::HandleTXCharConfirm(CHIPoBLEConState * conState, int status)
{
    // If the confirmation was successful...
    if (status == 0)
    {
        // Post an event to the Chip queue to process the indicate confirmation.
        ChipDeviceEvent event;
        event.Type                          = DeviceEventType::kCHIPoBLEIndicateConfirm;
        event.CHIPoBLEIndicateConfirm.ConId = conState->conn_idx;
        PlatformMgr().PostEventOrDie(&event);
    }
    else
    {
        ChipDeviceEvent event;
        event.Type                           = DeviceEventType::kCHIPoBLEConnectionError;
        event.CHIPoBLEConnectionError.ConId  = conState->conn_idx;
        event.CHIPoBLEConnectionError.Reason = BLE_ERROR_CHIPOBLE_PROTOCOL_ABORT;
        PlatformMgr().PostEventOrDie(&event);
    }
}

void BLEManagerImpl::beken_ble_cmd_cb(ble_cmd_t cmd, ble_cmd_param_t * param)
{
    ChipLogProgress(DeviceLayer, "cmd:%d idx:%d status:%d\r\n", cmd, param->cmd_idx, param->status);
    switch (cmd)
    {
    case BLE_CREATE_ADV:
        sInstance.mFlags.Set(Flags::kBEKENBLEADVCreate);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    case BLE_SET_ADV_DATA:
        sInstance.mFlags.Set(Flags::kBEKENBLEADVSetData);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    case BLE_SET_RSP_DATA:
        sInstance.mFlags.Set(Flags::kBEKENBLEADVSetRsp);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    case BLE_START_ADV: {
        uint32_t bleAdvTimeoutMs;
        sInstance.mFlags.Set(Flags::kBEKENBLEADVStarted);
        // if (sInstance.mFlags.Has(Flags::kAdvertisingIsFastADV)){
        bleAdvTimeoutMs = CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME;
        //}else{
        //    bleAdvTimeoutMs = CHIP_DEVICE_CONFIG_BLE_ADVERTISING_TIMEOUT;
        //}
        StartBleAdvTimeoutTimer(bleAdvTimeoutMs);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
    }
    break;
    case BLE_STOP_ADV:
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVStarted);
        ChipLogProgress(DeviceLayer, "CHIPoBLE advertising stopped");
        CancelBleAdvTimeoutTimer();
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    case BLE_DELETE_ADV:
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVCreate);
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVSetData);
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVSetRsp);
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVStarted);
        sInstance.adv_actv_idx = kUnusedIndex;
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    case BLE_CONN_DIS_CONN:
        break;
    default:
        break;
    }
}

#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
void BLEManagerImpl::HandleC3CharRead(void * param)
{
    CHIP_ERROR err = CHIP_NO_ERROR;
    chip::System::PacketBufferHandle bufferHandle;
    ble_read_req_t * r_req = (ble_read_req_t *) param;

    AdditionalDataPayloadGeneratorParams additionalDataPayloadParams;
    BitFlags<AdditionalDataFields> additionalDataFields;

#if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID)
    uint8_t rotatingDeviceIdUniqueId[ConfigurationManager::kRotatingDeviceIDUniqueIDLength] = {};
    MutableByteSpan rotatingDeviceIdUniqueIdSpan(rotatingDeviceIdUniqueId);

    err = DeviceLayer::GetDeviceInstanceInfoProvider()->GetRotatingDeviceIdUniqueId(rotatingDeviceIdUniqueIdSpan);
    SuccessOrExit(err);
    err = ConfigurationMgr().GetLifetimeCounter(additionalDataPayloadParams.rotatingDeviceIdLifetimeCounter);
    SuccessOrExit(err);
    additionalDataPayloadParams.rotatingDeviceIdUniqueId = rotatingDeviceIdUniqueIdSpan;
    additionalDataFields.Set(AdditionalDataFields::RotatingDeviceId);
#endif /* CHIP_ENABLE_ROTATING_DEVICE_ID */

    err = AdditionalDataPayloadGenerator().generateAdditionalDataPayload(additionalDataPayloadParams, bufferHandle,
                                                                         additionalDataFields);
    SuccessOrExit(err);
    if (r_req->value == NULL)
    {
        ChipLogError(DeviceLayer, "param->value == NULL");
        return;
    }
    memcpy(r_req->value, bufferHandle->Start(), bufferHandle->DataLength());
    r_req->length = bufferHandle->DataLength();
exit:
    if (err != CHIP_NO_ERROR)
    {
        ChipLogError(DeviceLayer, "Failed to generate TLV encoded Additional Data");
    }
    return;
}
#endif

void BLEManagerImpl::ble_event_notice(ble_notice_t notice, void * param)
{
    /// BLEManagerImpl * blemgr = static_cast<BLEManagerImpl *>(param);
    static int conn_idx = 0; // TODO. will improve this when driver notify the status and channel to app.
    switch (notice)
    {
    case BLE_5_STACK_OK: {
        ChipLogProgress(DeviceLayer, "ble stack ok");
        sInstance.mFlags.Set(Flags::kAMEBABLEStackInitialized);
    }
    break;
    case BLE_5_WRITE_EVENT: {
        ble_write_req_t * w_req = (ble_write_req_t *) param;
        ChipLogProgress(DeviceLayer, "write_cb:conn_idx:%d, prf_id:%d, add_id:%d, len:%d, data[0]:%02x\r\n", w_req->conn_idx,
                        w_req->prf_id, w_req->att_idx, w_req->len, w_req->value[0]);
        if (w_req->att_idx == SVR_FFF6_TX_VALUE)
        {
            sInstance.HandleRXCharWrite((uint8_t *) &w_req->value[0], w_req->len, w_req->conn_idx);
        }
        else if (w_req->att_idx == SVR_FFF6_TX_CFG)
        {
            int notificationsEnabled = w_req->value[0] | (w_req->value[0] << 8);
            sInstance.HandleTXCharCCCDWrite(w_req->conn_idx, notificationsEnabled);
        }
        else if (w_req->att_idx == SVR_FFF6_RX_VALUE)
        {
            sInstance.HandleRXCharWrite((uint8_t *) &w_req->value[0], w_req->len, w_req->conn_idx);
        }
        break;
    }
    case BLE_5_READ_EVENT: {
        ble_read_req_t * r_req = (ble_read_req_t *) param;
        ChipLogProgress(DeviceLayer, "read_cb:conn_idx:%d, prf_id:%d, add_id:%d\r\n", r_req->conn_idx, r_req->prf_id,
                        r_req->att_idx);
        if (r_req->att_idx == SVR_FFF6_RX_VALUE)
        {
            sInstance.HandleTXCharRead(param);
        }
        if (r_req->att_idx == SVR_FFF6_TX_CFG)
        {
            sInstance.HandleTXCharCCCDRead(param);
        }
#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
        if (r_req->att_idx == SVR_FFF6_C3_VALUE)
        {
            ChipLogProgress(DeviceLayer, "SVR_FFF6_OPT_VALUE!!!!\r\n");
            sInstance.HandleTXCharRead((void *) param);
        }
#endif
        break;
    }
    case BLE_5_TX_DONE: {
        ChipLogProgress(DeviceLayer, "BLE_5_TX_DONE");
#if 0
        tx_done_rsp_t* txd_rsp = (tx_done_rsp_t*)param;
        if(txd_rsp) {
            CHIPoBLEConState * conState = sInstance.GetConnectionState(txd_rsp->conn_idx,false);
            if (conState != NULL)
            {
                sInstance.HandleTXCharConfirm(conState, txd_rsp->status);
            }
        }
#endif
        CHIPoBLEConState * conState = sInstance.GetConnectionState(conn_idx, false);
        if (conState != NULL)
        {
            sInstance.HandleTXCharConfirm(conState, 0);
        }
    }
    break;
    case BLE_5_MTU_CHANGE: {
        ble_mtu_change_t * m_ind = (ble_mtu_change_t *) param;
        ChipLogProgress(DeviceLayer, "m_ind:conn_idx:%d, mtu_size:%d\r\n", m_ind->conn_idx, m_ind->mtu_size);
        CHIPoBLEConState * conState = sInstance.GetConnectionState(m_ind->conn_idx);
        if (conState != NULL)
        {
            conState->mtu = (m_ind->mtu_size >= (1 << 10)) ? ((1 << 10) - 1) : m_ind->mtu_size;
        }
        break;
    }
    case BLE_5_CONNECT_EVENT: {
        ble_conn_ind_t * c_ind = (ble_conn_ind_t *) param;
        ChipLogProgress(DeviceLayer, "BLE GATT connection established (con %u)", c_ind->conn_idx);
        ChipLogProgress(DeviceLayer, "c_ind:conn_idx:%d, addr_type:%d, peer_addr:%02x:%02x:%02x:%02x:%02x:%02x\r\n",
                        c_ind->conn_idx, c_ind->peer_addr_type, c_ind->peer_addr[0], c_ind->peer_addr[1], c_ind->peer_addr[2],
                        c_ind->peer_addr[3], c_ind->peer_addr[4], c_ind->peer_addr[5]);
        sInstance.mFlags.Clear(Flags::kBEKENBLEADVStarted);
        CHIPoBLEConState * bleConnState = sInstance.GetConnectionState(c_ind->conn_idx, true);
        if (bleConnState == NULL)
        {
            ChipLogError(DeviceLayer, "BLE_5_CONNECT_EVENT failed");
            int ext_evt = DriveBLEExtPerfEvt_DISCONNECT | (c_ind->conn_idx << 8);
            PlatformMgr().ScheduleWork(DriveBLEExtPerf, ext_evt);
        }
        conn_idx = c_ind->conn_idx;
        break;
    }
    case BLE_5_DISCONNECT_EVENT: {
        ble_discon_ind_t * d_ind = (ble_discon_ind_t *) param;
        ChipLogProgress(DeviceLayer, "d_ind:conn_idx:%d,reason:%d\r\n", d_ind->conn_idx, d_ind->reason);
        sInstance.HandleGAPDisconnect(d_ind->conn_idx, d_ind->reason);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    }
    case BLE_5_ATT_INFO_REQ: {
        ble_att_info_req_t * a_ind = (ble_att_info_req_t *) param;
        ChipLogProgress(DeviceLayer, "a_ind:conn_idx:%d\r\n", a_ind->conn_idx);
        if (SVR_FFF6_RX_VALUE == a_ind->att_idx)
        {
            a_ind->length = 512;
            a_ind->status = BK_ERR_BLE_SUCCESS;
        }
        else if (SVR_FFF6_TX_CFG == a_ind->att_idx)
        {
            a_ind->length = 2;
            a_ind->status = BK_ERR_BLE_SUCCESS;
        }
        break;
    }
    case BLE_5_CREATE_DB: {
        ble_create_db_t * cd_ind = (ble_create_db_t *) param;
        ChipLogProgress(DeviceLayer, "cd_ind:prf_id:%d, status:%d\r\n", cd_ind->prf_id, cd_ind->status);
        sInstance.mFlags.Set(Flags::kBekenBLESGATTSReady);
        PlatformMgr().ScheduleWork(DriveBLEState, 0);
        break;
    }
    default: {
        ChipLogProgress(DeviceLayer, "Unhandled event:%x", notice);
    }
    break;
    }
}

} // namespace Internal
} // namespace DeviceLayer
} // namespace chip
#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE