#include <stdio.h>
#include <string.h>
#include "ql_bt.h"
#include "ql_rtos.h"
#include "ql_log.h"
#include "ql_application.h"
#include "ql_audio.h"
#include "ql_gpio.h"
#include "ql_bt_drive.h"

#include "ql_fs.h"


#define OC_MODE 3 // 0=ec200m 1=800m 2=eg915keu_la 3=ec800k
#define BLE_DEMO_SLAVE
//#define BLE_DEMO_MASTER
#define BLE_DEMO_HCI_CON_HANDLE_INVALID 0xffff

#define LE_NAME "QUEC SLAVE"
#define LE_HID_APPEARANCE 962

//QL_BT_USE_UART 1 main uart
//QL_BT_USE_UART 2 uart3
//QL_BT_USE_UART 3 uart4


#if OC_MODE==0
#define QL_BT_USE_UART 3 //3--uart4
#define BT_REMOTE_HID_HOST 1
#define QL_GPIO_BT_POWER 77
#define QL_GPIO_BT_RESET 126
#define QL_GPIO_BT_LDO_EN 37
#define QL_GPIO_BT_WAKEUP_HOST 117
#define QL_GPIO_HOST_WAKEUP_BT 118 
#elif OC_MODE==1
#define QL_BT_USE_UART 1
#define QL_GPIO_BT_POWER 26
#define QL_GPIO_BT_RESET 24
#define QL_GPIO_BT_LDO_EN 23
#define QL_GPIO_BT_WAKEUP_HOST 25
#define QL_GPIO_HOST_WAKEUP_BT 14
#elif OC_MODE==2
#define QL_BT_USE_UART 2
#define QL_GPIO_BT_RESET   37
#define QL_GPIO_BT_LDO_EN  57
#define QL_GPIO_BT_WAKEUP_HOST 84
#define QL_GPIO_HOST_WAKEUP_BT 89
#define QL_GPIO_BT_POWER   90
#elif OC_MODE==3
#define QL_BT_USE_UART 1
#define QL_GPIO_BT_RESET   84
#define QL_GPIO_BT_LDO_EN  86
#define QL_GPIO_BT_WAKEUP_HOST 56
#define QL_GPIO_HOST_WAKEUP_BT 57
#define QL_GPIO_BT_POWER   90
#endif

void print_int_data(const uint8_t *data, size_t length)
{
    ql_app_log("\r\n");
    for (size_t i = 0; i < length; ++i)
    {
        printf(" %02X ", data[i]);
    }
    ql_app_log("\r\n");
}
//BLE SLAVE
#ifdef BLE_DEMO_SLAVE

#define BAS_SUPPORT 1
#define CUSTOM_SUPPORT 1
#define HID_SUPPORT 0
#include "ql_ble_slave_profile.h"
int user_ble_slave_handle = BLE_DEMO_HCI_CON_HANDLE_INVALID;
volatile uint8_t ble_demo_loop_test_buf[256];
volatile uint16_t user_ble_slave_notify_flag = 0;
volatile uint16_t ble_demo_loop_test_handle = 0;

uint32_t ble_demo_min(uint32_t a, uint32_t b)
{
    return (a < b) ? a : b;
}

uint16_t ble_demo_little_endian_read_16(const uint8_t *buffer, int position)
{
    return (uint16_t)(((uint16_t)buffer[position]) | (((uint16_t)buffer[position + 1]) << 8));
}

// att_read_callback helpers
uint16_t ble_demo_att_read_callback_handle_blob(const uint8_t *blob, uint16_t blob_size, uint16_t offset, uint8_t *buffer,
                                                uint16_t buffer_size)
{

    if (buffer != NULL)
    {
        uint16_t bytes_to_copy = 0;
        if (blob_size >= offset)
        {
            bytes_to_copy = ble_demo_min(blob_size - offset, buffer_size);
            (void)memcpy(buffer, &blob[offset], bytes_to_copy);
        }
        return bytes_to_copy;
    }
    else
    {
        return blob_size;
    }
}

static uint16_t att_read_callback(uint16_t con_handle, uint16_t att_handle, uint16_t offset, uint8_t *buffer, uint16_t buffer_size);
static int att_write_callback(uint16_t con_handle, uint16_t att_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer,
                              uint16_t buffer_size);

// test param
static uint8_t test_value = 0;
static uint8_t test_buf[256];

static uint8_t service_changed;
static uint16_t service_changed_client_configuration;

#if BAS_SUPPORT==1
static uint8_t battery_value;
static uint16_t battery_value_client_configuration;
#endif

#if CUSTOM_SUPPORT==1
static uint8_t custom_value1[256];
static uint16_t custom_value_client_configuration1;
static uint8_t custom_value2[20];
static uint16_t custom_value_client_configuration2;
#endif

#if HID_SUPPORT ==1
asdas
static uint8_t hid_protocol_mode = 1; // 0: boot mode, 1: report mode
static uint8_t hid_control_point = 1; // 0: suspend, 1: running
static uint16_t hid_report_input_input_value = 0;
static uint16_t hid_report_input_input_value_client_configuration = 0;
static uint16_t hid_report_output_input_value = 0;
static uint16_t hid_report_output_input_value_client_configuration = 0;
static uint16_t hid_report_feature_input_value = 0;
static uint16_t hid_report_feature_input_value_client_configuration = 0;
static uint16_t hid_boot_mouse_input_value = 0;
static uint16_t hid_boot_mouse_input_value_client_configuration = 0;
static uint16_t hid_boot_keyboard_input_value = 0;
static uint16_t hid_boot_keyboard_input_value_client_configuration = 0;
#endif

static uint16_t att_read_callback(uint16_t connection_handle, uint16_t att_handle, uint16_t offset, uint8_t *buffer,
                                  uint16_t buffer_size)
{

    ql_app_log("[DEMO][%s] connection_handle: %d, att_handle: 0x%04x, offset: %d, buffer: 0x%x, buffer_size: %d", __func__, connection_handle,
               att_handle, offset,
               buffer, buffer_size);

    if (buffer == NULL)
    {
        ql_app_log("[DEMO][%s] used for check value len", __func__);
    }

    switch (att_handle)
    {
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_GATT_SERVICE_CHANGED_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            service_changed++;
            ql_app_log("[DEMO][%s] service_changed_client_configuration: %d, service_changed: %d", __func__, service_changed_client_configuration, service_changed);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&service_changed_client_configuration, sizeof(service_changed_client_configuration), offset,
                                                      buffer, buffer_size);
#if BAS_SUPPORT ==1
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BATTERY_LEVEL_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            battery_value++;
            ql_app_log("[DEMO][%s] battery_value: %d", __func__, battery_value);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&battery_value, sizeof(battery_value), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BATTERY_LEVEL_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            battery_value++;
            ql_app_log("[DEMO][%s] battery_value_client_configuration: %d, battery_value: %d", __func__, battery_value_client_configuration, battery_value);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&battery_value_client_configuration, sizeof(battery_value_client_configuration), offset, buffer,
                                                      buffer_size);
#endif
#if CUSTOM_SUPPORT==1
    case ATT_CHARACTERISTIC_AFAEADAC_ABAA_A9A8_A7A6_A5A4A3A2A1A0_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            memcpy(custom_value1, test_buf, sizeof(custom_value1));
            ql_app_log("[DEMO][%s] custom_value1: 0x%x", __func__, custom_value1);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)custom_value1, sizeof(custom_value1), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_AFAEADAC_ABAA_A9A8_A7A6_A5A4A3A2A1A0_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            custom_value1[0]++;
            ql_app_log("[DEMO][%s] custom_value_client_configuration1: %d, custom_value1: %d", __func__, custom_value_client_configuration1, custom_value1[0]);
        }
        // att_server_request_can_send_now_event(connection_handle);
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&custom_value_client_configuration1, sizeof(custom_value_client_configuration1), offset, buffer,
                                                      buffer_size);
    case ATT_CHARACTERISTIC_12345678_1234_5678_ABCD_BA9876543210_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            memcpy(custom_value2, test_buf, sizeof(custom_value2));
            ql_app_log("[DEMO][%s] custom_value2: %d", __func__, custom_value2);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)custom_value2, sizeof(custom_value2), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_12345678_1234_5678_ABCD_BA9876543210_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            custom_value2[0]++;
            ql_app_log("[DEMO][%s] custom_value_client_configuration2: %d, custom_value2: %d", __func__, custom_value_client_configuration2, custom_value2[0]);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&custom_value_client_configuration2, sizeof(custom_value_client_configuration2), offset, buffer,
                                                      buffer_size);
#endif
#if HID_SUPPORT ==1
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_PROTOCOL_MODE_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_protocol_mode: %d", __func__, hid_protocol_mode);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_protocol_mode, sizeof(hid_protocol_mode), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_MAP_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_report_map: %d", __func__, hid_report_map);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_report_map, sizeof(hid_report_map), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT_01_VALUE_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_control_point: %d", __func__, hid_control_point);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_control_point, sizeof(hid_control_point), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_report_input_input_value_client_configuration: %d", __func__, hid_report_input_input_value_client_configuration);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_report_input_input_value_client_configuration,
                                                      sizeof(hid_report_input_input_value_client_configuration), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_02_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_report_output_input_value_client_configuration: %d", __func__, hid_report_output_input_value_client_configuration);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_report_output_input_value_client_configuration,
                                                      sizeof(hid_report_output_input_value_client_configuration), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_03_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_report_feature_input_value_client_configuration: %d", __func__, hid_report_feature_input_value_client_configuration);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_report_feature_input_value_client_configuration,
                                                      sizeof(hid_report_feature_input_value_client_configuration), offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_boot_mouse_input_value_client_configuration: %d", __func__, hid_boot_mouse_input_value_client_configuration);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_boot_mouse_input_value_client_configuration,
                                                      sizeof(hid_boot_mouse_input_value_client_configuration),
                                                      offset, buffer, buffer_size);
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        if (buffer != NULL)
        {
            ql_app_log("[DEMO][%s] hid_boot_keyboard_input_value_client_configuration: %d", __func__, hid_boot_keyboard_input_value_client_configuration);
        }
        return ble_demo_att_read_callback_handle_blob((const uint8_t *)&hid_boot_keyboard_input_value_client_configuration,
                                                      sizeof(hid_boot_keyboard_input_value_client_configuration), offset, buffer, buffer_size);
#endif
    default:
        break;
    }

    return 0;
}

static int att_write_callback(uint16_t connection_handle, uint16_t att_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer,
                              uint16_t buffer_size)
{

    ql_app_log("[DEMO][%s] connection_handle: %d, att_handle: 0x%04x, offset: %d, buffer_size: %d", __func__, connection_handle, att_handle, offset, buffer_size);
    ql_app_log("att_write_callback:", buffer, buffer_size);

    switch (att_handle)
    {
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_GATT_SERVICE_CHANGED_01_CLIENT_CONFIGURATION_HANDLE:
        service_changed_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] service_changed_client_configuration: %d", __func__, service_changed_client_configuration);
        return 0;
#if BAS_SUPPORT==1
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BATTERY_LEVEL_01_CLIENT_CONFIGURATION_HANDLE:
        battery_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] battery_value_client_configuration: %d", __func__, battery_value_client_configuration);
        return 0;
#endif
#if CUSTOM_SUPPORT ==1
    case ATT_CHARACTERISTIC_AFAEADAC_ABAA_A9A8_A7A6_A5A4A3A2A1A0_01_CLIENT_CONFIGURATION_HANDLE:
        custom_value_client_configuration1 = ble_demo_little_endian_read_16(buffer, 0);

        user_ble_slave_notify_flag = custom_value_client_configuration1;

        ql_app_log("[DEMO][%s] custom_value_client_configuration1: %d", __func__, custom_value_client_configuration1);
        return 0;
    case ATT_CHARACTERISTIC_12345678_1234_5678_ABCD_BA9876543210_01_CLIENT_CONFIGURATION_HANDLE:
        custom_value_client_configuration2 = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] custom_value_client_configuration2: %d", __func__, custom_value_client_configuration2);
        return 0;
    case ATT_CHARACTERISTIC_12345678_1234_5678_ABCD_BA9876543210_01_VALUE_HANDLE:
        print_int_data(buffer, buffer_size);
    case ATT_CHARACTERISTIC_AFAEADAC_ABAA_A9A8_A7A6_A5A4A3A2A1A0_01_VALUE_HANDLE:
        print_int_data(buffer, buffer_size);

        return 0;
#endif
#if HID_SUPPORT==1
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_PROTOCOL_MODE_01_VALUE_HANDLE:
        hid_protocol_mode = buffer[0];
        ql_app_log("[DEMO][%s] hid_protocol_mode: %d(0: boot mode, 1: report mode)", __func__, hid_protocol_mode);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_HID_CONTROL_POINT_01_VALUE_HANDLE:
        hid_control_point = buffer[0];
        ql_app_log("[DEMO][%s] hid_control_point: %d(0: suspend, 1: running)", __func__, hid_control_point);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        hid_report_input_input_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] hid_report_input_input_value_client_configuration: %d", __func__, hid_report_input_input_value_client_configuration);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_02_CLIENT_CONFIGURATION_HANDLE:
        hid_report_output_input_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] hid_report_output_input_value_client_configuration: %d", __func__, hid_report_output_input_value_client_configuration);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_REPORT_03_CLIENT_CONFIGURATION_HANDLE:
        hid_report_feature_input_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] hid_report_feature_input_value_client_configuration: %d", __func__, hid_report_feature_input_value_client_configuration);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BOOT_KEYBOARD_INPUT_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        hid_boot_keyboard_input_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        return 0;
    case ATT_CHARACTERISTIC_ORG_BLUETOOTH_CHARACTERISTIC_BOOT_MOUSE_INPUT_REPORT_01_CLIENT_CONFIGURATION_HANDLE:
        hid_boot_mouse_input_value_client_configuration = ble_demo_little_endian_read_16(buffer, 0);
        ql_app_log("[DEMO][%s] hid_boot_mouse_input_value_client_configuration: %d", __func__, hid_boot_mouse_input_value_client_configuration);
        return 0;
#endif
    default:
        break;
    }
    return 0;
}
void ble_slave_demo_register(void)
{
    int i;
    for (i = 0; i < sizeof(test_buf); i++)
    {
        test_buf[i] = i;
    }

    memcpy((uint8_t *)ble_demo_loop_test_buf, test_buf, sizeof(ble_demo_loop_test_buf));
    ble_demo_loop_test_handle = ATT_CHARACTERISTIC_AFAEADAC_ABAA_A9A8_A7A6_A5A4A3A2A1A0_01_VALUE_HANDLE;

    ql_app_log("[DEMO] %s", __func__);
    ql_bt_le_register_att_service(profile_data, sizeof(profile_data), att_read_callback, att_write_callback);
}
#endif

#ifdef BLE_DEMO_MASTER
int user_ble_master_handle = 0xff;
volatile uint8_t ble_demo_master_test_buf[256];
volatile uint8_t user_ble_master_scan_flag = 0;

static unsigned short user_att_name_handle = BLE_DEMO_HCI_CON_HANDLE_INVALID;
#define USER_TEST_ATT_NAME 0X1213
#define USER_TEST_SLAVE_BLE_NAME "test_server"

char *ble_demo_uuid128_to_str(const uint8_t *uuid)
{
    static char appbt_uuid128_to_str_buffer[32 + 4 + 1];
    int i;
    int j = 0;
    // after 4, 6, 8, and 10 bytes = XYXYXYXY-XYXY-XYXY-XYXY-XYXYXYXYXYXY, there's a dash
    const int dash_locations = (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9);
    for (i = 0; i < 16; i++)
    {
        snprintf(appbt_uuid128_to_str_buffer + i * 2 + j, 4, "%02x", uuid[i]);
        if (dash_locations & (1 << i))
        {
            snprintf(appbt_uuid128_to_str_buffer + i * 2 + 2 + j, 4, "-");
            j++;
        }
    }
    return appbt_uuid128_to_str_buffer;
}
char *ble_demo_print_properties(uint16_t properties)
{
    static char properties_log[100] = {0};
    int offset = 0;
    if ((properties & LE_ATT_CHARC_PROP_READ) == LE_ATT_CHARC_PROP_READ)
    {
        snprintf(properties_log + offset, strlen("read | ") + 1, "read | ");
        offset += strlen("read | ");
    }
    if ((properties & LE_ATT_CHARC_PROP_WWP) == LE_ATT_CHARC_PROP_WWP)
    {
        snprintf(properties_log + offset, strlen("write_without_response | ") + 1, "write_without_response | ");
        offset += strlen("write_without_response | ");
    }
    if ((properties & LE_ATT_CHARC_PROP_WRITE) == LE_ATT_CHARC_PROP_WRITE)
    {
        snprintf(properties_log + offset, strlen("write | ") + 1, "write | ");
        offset += strlen("write | ");
    }
    if ((properties & LE_ATT_CHARC_PROP_NOTIFY) == LE_ATT_CHARC_PROP_NOTIFY)
    {
        snprintf(properties_log + offset, strlen("notify | ") + 1, "notify | ");
        offset += strlen("notify | ");
    }
    if ((properties & LE_ATT_CHARC_PROP_INDICATE) == LE_ATT_CHARC_PROP_INDICATE)
    {
        snprintf(properties_log + offset, strlen("indicate | ") + 1, "indicate | ");
        offset += strlen("indicate | ");
    }
    snprintf(properties_log + offset - 3, 1, "~");
    return properties_log;
}
void master_name_scan_event_handle(struct bt_event_le_scan_event *event)
{
    int index = 0;
    int total_size = event->length;
    while (total_size > 0 && (event->event_type == LE_PDU_TYPE_IND || event->event_type == LE_PDU_TYPE_SCAN_RESP))
    {
        int length = event->data[index];
        int type = event->data[index + 1];
        ql_app_log("[DEMO] event_type: %d, address_type: %d, address: %02x%02x%02x%02x%02x%02x, handle type %02x, length %d, index %d , rssi %d",
                   event->event_type, event->address_type,
                   event->address.bytes[0], event->address.bytes[1],
                   event->address.bytes[2], event->address.bytes[3],
                   event->address.bytes[4], event->address.bytes[5],
                   type, length, index, event->rssi);

        switch (type)
        {
        case LE_GAP_TYPE_COMPLETE_NAME:
        {
            char name[31];
            memset(name, 0, 31);
            memcpy(name, &event->data[index + 2], length - 1);
            ql_app_log("[DEMO] handle name %s", name);
            if (strstr(name, USER_TEST_SLAVE_BLE_NAME))
            {
                ql_bt_le_scan_stop();
                ql_app_log("[DEMO][LE-client]found test device. "
                           "address type %d, "
                           "addrss %02x%02x%02x%02x%02x%02x\r\n",
                           event->address_type,
                           event->address.bytes[0], event->address.bytes[1],
                           event->address.bytes[2], event->address.bytes[3],
                           event->address.bytes[4], event->address.bytes[5]);
                ql_bt_le_connect(event->address, event->address_type);
            }
            break;
        }
        default:
            break;
        }
        index += (length + 1);
        total_size -= (length + 1);
    }
}
#endif

static void ql_bt_open_gpio_set() //?????????pin?????????????GPIO??
{
    ql_gpio_init(QL_GPIO_BT_POWER, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
    ql_gpio_init(QL_GPIO_BT_RESET, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
    ql_gpio_init(QL_GPIO_BT_LDO_EN, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
    ql_gpio_init(QL_GPIO_BT_WAKEUP_HOST, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
    ql_gpio_init(QL_GPIO_HOST_WAKEUP_BT, PIN_DIRECTION_OUT, PIN_PULL_DISABLE, PIN_LEVEL_LOW);
}
static bt_uart_cfg ql_bt_uart_port =
    {
        QL_BT_USE_UART,  //you can change it, if you use other UART port
        1,               //do not change it
        0,               //do not change it
        0,               //do not change it
        bt_rx_int,       //do not change it
        0,               //do not change it
        0,               //do not change it
        BAUDRATE_921600, //do not change it. it is a default baudrate. stack will change baudrate accroding bt_user_cfg
        BT_DATA_8,       //do not change it
        BT_PARITY_NONE,  //do not change it
        NULL,            //do not change it. host stack will use it
        NULL,            //do not change it. host stack will use it
};
static struct bt_user_cfg cfg = {
    .bt_mode = BT_MODE_BR_LE,
    .h4_h5 = BT_HCI_MODE_H5,
    .firmware_where = BT_FIRMWARE_AT_FLASH,
    .hw.baudrate = BAUDRATE_921600,
    .hw.uart_cfg = &ql_bt_uart_port,
    .hw.reset_pin = QL_GPIO_BT_RESET,
    .hw.pwdn_pin = QL_GPIO_BT_LDO_EN,
    .hw.host_wakeup_bt_pin = QL_GPIO_HOST_WAKEUP_BT,
    .hw.bt_wakeup_host_pin = QL_GPIO_BT_WAKEUP_HOST,
    .profile = {
        .prf = BT_HFP_PRF | BT_A2DP_SOURCE_PRF | BT_AVRCP_PRF | BT_SPP_PRF | BT_OBEX_PRF,
    },
    .br_common = {
        .name = "QUECTEL",
        .io_capability = 3,
    },

};


static void ql_bt_usr_handle_ble(int status, void *event_data)
{
    char buffer[256] = {0};
    switch (status)
    {

    case BTTASK_IND_LE_GATT_CONNECTED:

    {
        struct bt_event_le_att_connected *connect = (struct bt_event_le_att_connected *)event_data;
        ql_app_log("[DEMO]handle GATT connected(%d) handle %d "
                   "%02x%02x%02x%02x%02x%02x type %d\r\n",
                   connect->role,
                   connect->acl_handle,
                   connect->addr.bytes[0], connect->addr.bytes[1],
                   connect->addr.bytes[2], connect->addr.bytes[3],
                   connect->addr.bytes[4], connect->addr.bytes[5],
                   connect->addr_type);
        if (connect->role == 1)
        {
#ifdef BLE_DEMO_SLAVE
            user_ble_slave_handle = connect->acl_handle;

            ql_bt_le_set_adv_enable(0);
            ql_le_custom_mtu_request(user_ble_slave_handle, 400);
#endif
        }
#ifdef BLE_DEMO_MASTER
        else
        {
            user_ble_master_handle = connect->acl_handle;
            ql_le_custom_mtu_request(user_ble_master_handle, 400);

            ql_le_custom_gatt_scan_start(user_ble_master_handle);
        }
#endif
       
        break;
    }

    case BTTASK_IND_LE_GATT_DISCONNECTED:
    {
        int *conn_handle = (int *)event_data;
#ifdef BLE_DEMO_SLAVE
        if (user_ble_slave_handle == *conn_handle)
        {
            ql_bt_le_set_adv_enable(1);
            user_ble_slave_handle = BLE_DEMO_HCI_CON_HANDLE_INVALID;
        }
#endif
#ifdef BLE_DEMO_MASTER
        if (user_ble_master_handle == *conn_handle)
        {
            user_ble_master_handle = BLE_DEMO_HCI_CON_HANDLE_INVALID;
        }
#endif

        ql_app_log("[DEMO]GATT disconnected, handle: %d\n", *conn_handle);
        break;
    }
    case BTTASK_IND_LE_CUSTOM_SCAN_EVENT:
    {
        struct bt_event_le_custom_scan_event *scan = (struct bt_event_le_custom_scan_event *)event_data;
        struct bt_event_le_scan_event *p_item = scan->item;
        int i;

        ql_app_log("[DEMO]handle BTTASK_IND_LE_CUSTOM_SCAN_EVENT, count: %d: ", scan->count);

        for (i = 0; i < scan->count; i++)
        {
            int total_size = (int)p_item->length;

            ql_app_log("[DEMO]handle BTTASK_IND_LE_CUSTOM_SCAN_EVENT from: "
                       "%02x:%02x:%02x:%02x:%02x:%02x. length %d. type %d, rssi %dr\n",
                       p_item->address.bytes[0], p_item->address.bytes[1],
                       p_item->address.bytes[2], p_item->address.bytes[3],
                       p_item->address.bytes[4], p_item->address.bytes[5],
                       p_item->length, p_item->event_type,
                       p_item->rssi);

            p_item++;
        }

        break;
    }
    case BTTASK_IND_LE_CONNECTION_COMPLETE:
    {

        struct bt_event_le_connection_complete *le_conn_complete = (struct bt_event_le_connection_complete *)event_data;
        ql_app_log("[DEMO]le connection complete, status: %d, conn_handle: %d, role: %d, param: %d, %d, %d, clock_accuracy %d\r\n",
                   le_conn_complete->status, le_conn_complete->connection_handle, le_conn_complete->role, le_conn_complete->interval,
                   le_conn_complete->latency, le_conn_complete->timeout, le_conn_complete->clock_accuracy);

        break;
    }
    case BTTASK_IND_LE_DISCONNECTION_COMPLETE:
    {

        struct bt_event_le_disconnection_complete *le_disconn_complete = (struct bt_event_le_disconnection_complete *)event_data;
        ql_app_log("[DEMO]le disconnection complete, status: %d, conn_handle: %d, reason: 0x%x\r\n",
                   le_disconn_complete->status, le_disconn_complete->connection_handle, le_disconn_complete->reason);

        break;
    }

    case BTTASK_IND_LE_MTU_EXCHANGED:

    {
        struct bt_event_le_mtu_exchange *mtu = (struct bt_event_le_mtu_exchange *)event_data;
        ql_app_log("[DEMO]handle GATT MTU exchange message, mtu: %d, handle: %d", mtu->mut, mtu->acl_handle);

        break;
    }

    case BTTASK_IND_LE_CONNECTION_UPDATE_COMPLETE:
    {
        struct bt_event_le_connection_parameter_update *param = (struct bt_event_le_connection_parameter_update *)event_data;

        ql_app_log("[DEMO]handle LE_CONNECTION_UPDATE_COMPLETE, status: %d, conn_handle: 0x%x, interval: %d, latency: %d, timeout: %d",
                   param->status, param->conn_handle, param->conn_interval, param->slave_latency, param->supervision_timeout);

        break;
    }
    case BTTASK_IND_ADV_PHY_TXPOWER:
    {
        signed char *tx_power = (signed char *)event_data;
        ql_app_log("[DEMO]handle TX power %d\r\n", *tx_power);
        break;
    }
    case BTTASK_IND_SMP_PASSKEY:
    {
        struct bt_event_le_smp_passkey *passkey =
            (struct bt_event_le_smp_passkey *)event_data;

        ql_app_log("[DEMO]handle SMP PASSKEY %d %02X%02X%02X%02X%02X%02X\r\n",
                   passkey->passkey_value,
                   passkey->addr.bytes[0], passkey->addr.bytes[1],
                   passkey->addr.bytes[2], passkey->addr.bytes[3],
                   passkey->addr.bytes[4], passkey->addr.bytes[5]);

        break;
    }
    case BTTASK_IND_LE_ATT_INDICATION_COMPLETE:
    {
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_INDICATION_COMPLETE\n");
        break;
    }
    case BTTASK_IND_LE_ATT_EVENT_CAN_SEND_NOW:
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_EVENT_CAN_SEND_NOW\n");
        break;

    case BTTASK_IND_SLAVE_LE_BOND_COMPLETE:
    {
        struct bt_event_le_bond_complete *event =
            (struct bt_event_le_bond_complete *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_SLAVE_LE_BOND_COMPLETE, type: %d, address: %02x%02x%02x%02x%02x%02x\r\n",
                   event->address_type,
                   event->address.bytes[0], event->address.bytes[1], event->address.bytes[2],
                   event->address.bytes[3], event->address.bytes[4], event->address.bytes[5]);

        break;
    }

    case BTTASK_IND_LE_PAIR_COMPLETE:
    {
        struct bt_event_le_pair_complete *event =
            (struct bt_event_le_pair_complete *)event_data;
        ql_app_log("[DEMO]le pair complete, conn_handle: 0x%x, status: %d, reason: %d",
                   event->connection_handle, event->status, event->reason);

        break;
    }
    case BTTASK_IND_LE_IDENTITY_INFO:
    {
        ql_app_log("[DEMO] BTTASK_IND_LE_IDENTITY_INFO\n");
        struct bt_event_le_identity_info_event *info =
            (struct bt_event_le_identity_info_event *)event_data;
        if (info->success_flag == 1)
        {
            ql_app_log("[DEMO] identity success, index: %d, connection_handle: 0x%x\r\n"
                       "addr: %02x%02x%02x%02x%02x%02x, addr_type: %d\r\n"
                       "identity_addr: %02x%02x%02x%02x%02x%02x, identity_addr_type: %d\r\n",
                       info->index, info->connection_handle,
                       info->address.bytes[0], info->address.bytes[1],
                       info->address.bytes[2], info->address.bytes[3],
                       info->address.bytes[4], info->address.bytes[5],
                       info->address_type,
                       info->identity_address.bytes[0], info->identity_address.bytes[1],
                       info->identity_address.bytes[2], info->identity_address.bytes[3],
                       info->identity_address.bytes[4], info->identity_address.bytes[5],
                       info->identity_address_type);
        }
        else
        {
            ql_app_log(
                "[DEMO] identity fail, index: %d, connection_handle: 0x%x\r\n"
                "addr: %02x%02x%02x%02x%02x%02x, addr_type: %d\r\n",
                info->index, info->connection_handle,
                info->address.bytes[0], info->address.bytes[1],
                info->address.bytes[2], info->address.bytes[3],
                info->address.bytes[4], info->address.bytes[5],
                info->address_type);
        }

        break;
    }

    case BTTASK_IND_LE_DB_CONTROL_GET_INFO:
    {
        ql_app_log("[DEMO] BTTASK_IND_LE_DB_CONTROL_GET_INFO\n");
        struct bt_event_le_get_pair_info_event *info =
            (struct bt_event_le_get_pair_info_event *)event_data;

        ql_app_log("[DEMO] index: %d, seq: %d, valid count: %d, max count: %d, "
                   "addr: %02x%02x%02x%02x%02x%02x, addr_type: %d\r\n",
                   info->index, info->seq, info->valid_count, info->max_count,
                   info->identity_address.bytes[0], info->identity_address.bytes[1],
                   info->identity_address.bytes[2], info->identity_address.bytes[3],
                   info->identity_address.bytes[4], info->identity_address.bytes[5],
                   info->identity_address_type);

        break;
    }

#ifdef BLE_DEMO_MASTER
    case BTTASK_IND_LE_GATT_SCAN_RESULT:
    {
        struct bt_event_le_gatt_scan_result *result =
            (struct bt_event_le_gatt_scan_result *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_GATT_SCAN_RESULT, connection_handle: 0x%x, status: %d\n", result->connection_handle, result->status);
        if (0 == result->status)
        {
            ql_app_log("[DEMO] gatt scan success\n");
#ifdef BLE_DEMO_MASTER
            user_ble_master_scan_flag = 1;
#endif
        }
        break;
    }
    case BTTASK_IND_LE_ATT_EVENT_CAN_WRITE_NOW:
    {
        struct bt_event_le_att_can_write_now *event =
            (struct bt_event_le_att_can_write_now *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_EVENT_CAN_WRITE_NOW, conn: 0x%x, write_type: %d\n", event->connection_handle, event->write_type);
        break;
    }

    case BTTASK_IND_LE_ATT_EVENT_WRITE_FLOW_CONTROL:
    {
        struct bt_event_le_write_flow_control_event *event = (struct bt_event_le_write_flow_control_event *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_EVENT_WRITE_FLOW_CONTROL, flow control: %s\n", event->enable ? "wait" : "continue");

        break;
    }

    case BTTASK_IND_LE_ATT_EVENT_READ_DATA_RESULT:
    {
        struct bt_event_le_att_read_data_result *event =
            (struct bt_event_le_att_read_data_result *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_EVENT_READ_DATA_RESULT, connection_handle: 0x%x, value_handle: 0x%x, value_offset: %d, value_length: %d\n",
                   event->connection_handle, event->value_handle, event->value_offset, event->value_len);
        print_int_data(event->value, event->value_len);
        break;
    }
    case BTTASK_IND_LE_ATT_EVENT_READ_OVER_RESULT:
    {
        struct bt_event_le_att_read_over_result *event =
            (struct bt_event_le_att_read_over_result *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_ATT_EVENT_READ_OVER_RESULT, connection_handle: 0x%x, att_status: %d\n",
                   event->connection_handle, event->att_status);

        break;
    }
    case BTTASK_IND_LE_CLIENT_HANDLE_NOTIFY:
    {
        struct bt_event_le_client_handle_notify *notify =
            (struct bt_event_le_client_handle_notify *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_CLIENT_HANDLE_NOTIFY, connection_handle: 0x%x, value_handle: 0x%x, value_length: %d\n",
                   notify->connection_handle, notify->value_handle, notify->value_length);
        print_int_data(notify->value, notify->value_length);

        break;
    }
    case BTTASK_IND_LE_CLIENT_HANDLE_INDIATION:
    {
        struct bt_event_le_client_handle_indication *indication =
            (struct bt_event_le_client_handle_indication *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_CLIENT_HANDLE_INDIATION, connection_handle: 0x%x, value_handle: 0x%x, value_length: %d\n",
                   indication->connection_handle, indication->value_handle, indication->value_length);
        print_int_data(indication->value, indication->value_length);
        break;
    }
    case BTTASK_IND_LE_GATT_SCAN_DUMP_SERVICE:
    {

        struct bt_event_le_gatt_scan_dump_service *result =
            (struct bt_event_le_gatt_scan_dump_service *)event_data;
        gatt_client_asr_service_t *service = &result->service;
        if (service->uuid16)
        {
            ql_app_log("[DEMO]* service: [0x%x-0x%x], uuid 0x%x",
                       service->start_group_handle, service->end_group_handle, service->uuid16);
        }
        else
        {
            ql_app_log("[DEMO]* service: [0x%x-0x%x], uuid  %s",
                       service->start_group_handle, service->end_group_handle, ble_demo_uuid128_to_str(service->uuid128));
        }

        break;
    }
    case BTTASK_IND_LE_GATT_SCAN_DUMP_CHARACTERISTIC:
    {

        struct bt_event_le_gatt_scan_dump_characteristic *result =
            (struct bt_event_le_gatt_scan_dump_characteristic *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_GATT_SCAN_DUMP_CHARACTERISTIC, connection_handle: 0x%x\n", result->connection_handle);
        gatt_client_asr_characteristic_t *characteristic = &result->characteristic;
        if (characteristic->uuid16)
        {
            ql_app_log("[DEMO]*   characteristic: [0x%x-0x%x-0x%x], properties 0x%x(%s), uuid 0x%x",
                       characteristic->start_handle, characteristic->value_handle, characteristic->end_handle, characteristic->properties,
                       ble_demo_print_properties(characteristic->properties), characteristic->uuid16);
            if (characteristic->uuid16 == USER_TEST_ATT_NAME)
            {
                ql_app_log("[DEMO] find device name att handle: 0x%x\n", characteristic->value_handle);
                user_att_name_handle = characteristic->value_handle;
            }
        }
        else
        {

            ql_app_log("[DEMO]*   characteristic: [0x%x-0x%x-0x%x], properties 0x%x(%s), uuid %s",
                       characteristic->start_handle, characteristic->value_handle, characteristic->end_handle, characteristic->properties,
                       ble_demo_print_properties(characteristic->properties), ble_demo_uuid128_to_str(characteristic->uuid128));
#if 0
                 if (strcmp(ble_demo_uuid128_to_str(characteristic->uuid128), USER_TEST_ATT_NAME) == 0)
                    {
                    ql_app_log("[DEMO] find device name att handle: 0x%x\n", characteristic->value_handle);
                    user_att_name_handle = characteristic->value_handle;
                    }
#endif
        }

        break;
    }
    case BTTASK_IND_LE_GATT_SCAN_DUMP_DESCRIPTOR:
    {
        struct bt_event_le_gatt_scan_dump_descriptor *result =
            (struct bt_event_le_gatt_scan_dump_descriptor *)event_data;
        ql_app_log("[DEMO] BTTASK_IND_LE_GATT_SCAN_DUMP_DESCRIPTOR, connection_handle: 0x%x\n", result->connection_handle);
        gatt_client_asr_characteristic_descriptor_t *descriptor = &result->descriptor;
        if (descriptor->uuid16)
        {
            ql_app_log("[DEMO]* descriptor, handle: 0x%x, uuid 0x%x", descriptor->handle, descriptor->uuid16);
        }
        else
        {

            ql_app_log("[DEMO]* descriptor, handle: 0x%x, uuid %s", descriptor->handle, ble_demo_uuid128_to_str(descriptor->uuid128));
        }
        break;
    }
#endif

    }
}

void ql_bt_le_service_process(void)
{
    struct bt_addr addr = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
    struct bt_task_le_adv_parameters adv_params;
    struct ql_bt_adv_params ql_params;

    ql_bt_le_set_random_address(addr);
    memset(&adv_params, 0, sizeof(struct bt_task_le_adv_parameters));
    adv_params.interval_min = 0x30; // 30ms
    adv_params.interval_max = 0x30; // 30ms
    adv_params.advertising_type = LE_ADV_TYPE_IND;
    adv_params.own_address_type = LE_ADDRESS_TYPE_RANDOM;
    adv_params.filter = 0; //
#if 1
        // set adv
    uint8_t adv_data[] = {
        0x02, LE_GAP_TYPE_FLAGS, 0x02,
        0x02, LE_GAP_TYPE_TX_POWER, 0x02,
        0x03, LE_GAP_TYPE_COMPLETE_SERVICE_LIST, LE_ATT_UUID_HID & 0xff, LE_ATT_UUID_HID >> 8,
        0x03, LE_GAP_TYPE_APPEARANCE, LE_HID_APPEARANCE & 0xff, LE_HID_APPEARANCE >> 8, // Appearance: HID Device
    };
    // set response
    uint8_t scan_response_data[] = {
        0x0b, LE_GAP_TYPE_COMPLETE_NAME, 'Q', 'U', 'E', 'C', ' ', 'S', 'L', 'A', 'V', 'E', // Complete Local Name
    };

#else
    unsigned char flags = 0;
    unsigned char txpower = 0;
    unsigned char service_uuid = 0;
    unsigned short uuid = 0;
    unsigned short appearance = 0;
    int adv_size = 0;
    int total = 0;
    unsigned char adv_data[31];
    unsigned char scan_response_data[31];
    int scan_response_size = 0;
    char name[31];
    memset(name, 0, 31);
    memset(scan_response_data, 0, 31);
    memset(adv_data, 0, 31);
    snprintf(name, 31, LE_NAME);


    flags = (1 << 1);
    adv_size = ql_bt_le_create_adv_data(LE_GAP_TYPE_FLAGS,
                                        &adv_data[total], 31 - total,
                                        &flags, sizeof(flags));
    total += adv_size;

    txpower = 2; // 2dbm
    adv_size = ql_bt_le_create_adv_data(LE_GAP_TYPE_TX_POWER,
                                        &adv_data[total], 31 - total,
                                        &txpower, sizeof(txpower));
    total += adv_size;

    uuid = LE_ATT_UUID_HID;
    adv_size = ql_bt_le_create_adv_data(LE_GAP_TYPE_COMPLETE_SERVICE_LIST,
                                        &adv_data[total], 31 - total,
                                        (unsigned char *)&uuid, sizeof(uuid));
    total += adv_size;

    appearance = LE_HID_APPEARANCE;
    adv_size = ql_bt_le_create_adv_data(LE_GAP_TYPE_APPEARANCE,
                                        &adv_data[total], 31 - total,
                                        (unsigned char *)&appearance, sizeof(appearance));
    total += adv_size;

    scan_response_size += ql_bt_le_create_adv_data(LE_GAP_TYPE_COMPLETE_NAME,
                                                   &scan_response_data[0], 31 - 0,
                                                   (unsigned char *)name, strlen(name));
#endif

    memset(&ql_params, 0, sizeof(struct ql_bt_adv_params));
    ql_params.adv_mode = BT_LE_ADV_LEGACY_MODE;
    ql_params.adv_data = adv_data;
    ql_params.adv_data_len = sizeof(adv_data);
    ql_params.scan_response_data = scan_response_data;
    ql_params.scan_response_data_len = sizeof(scan_response_data);
    ql_params.adv = &adv_params;
    ql_params.ext_adv = NULL; //

    ql_ble_set_adv_cfg_enable(&ql_params, 1);
}

static void ql_get_bt_start_result(int status, void *event_data)
{
    if (status == 0)
    {
        ql_app_log("OPEN BT sucess can do next step\r\n");
        struct bt_addr addr = {0};
        ql_bt_get_bt_address(&addr);
        ql_app_log("[QEUC_BT]get local bluetooth address: %02x%02x%02x%02x%02x%02x\r\n",
                   addr.bytes[0], addr.bytes[1], addr.bytes[2], addr.bytes[3], addr.bytes[4], addr.bytes[5]);
        ql_bt_register_event_handler(QL_BTTASK_IND_TYPE_LE, ql_bt_usr_handle_ble);
        ql_bt_le_set_pair_enable(1);
        for (int i = 0; i < 16; i++)
        {
            ql_le_remove_pair_info(i);
        }
        ql_bt_le_service_process();

#ifdef BLE_DEMO_SLAVE
        ble_slave_demo_register();
#endif

#ifdef BLE_DEMO_MASTER
        ql_bt_le_scan(0x01,   // LE_ACTIVE_SCAN
                      0x1F40, // interval - 5000ms
                      0x3E8,  // window - 1000ms
                      0x01,   //LE_ADDRESS_TYPE_RANDOM
                      master_name_scan_event_handle);
#endif
    }
     else if(status == 1) {
        ql_app_log("OPEN BT failed please check SW config\r\n");
    } 
    else if(status == 2){
        ql_app_log("BT  BTFIRMWARE_ASSERT\r\n");
    }
}

QuecOSStatus ql_bt_task_init(void)
{
    QuecOSStatus err = kNoErr;

    ql_log_mask_set(QL_LOG_APP_MASK, QL_LOG_PORT_UART | QL_LOG_PORT_USB);
    ql_app_log("ql_bt_task_init start\r\n");
    ql_rtos_task_sleep_s(10);

    ql_bt_open_gpio_set();
    err = ql_bt_device_open(&cfg, ql_get_bt_start_result);
    if (err != kNoErr)
    {
        ql_app_log("OPEN BT failed please check HW config\r\n");
    }

#ifdef BLE_DEMO_MASTER
    for (int i = 0; i < sizeof(ble_demo_master_test_buf); i++)
    {
        ble_demo_master_test_buf[i] = i;
    }
#endif

    while (1)
    {
#ifdef BLE_DEMO_MASTER
        if (user_ble_master_scan_flag == 1)
        {
            if (user_att_name_handle != BLE_DEMO_HCI_CON_HANDLE_INVALID)
            {
                ql_le_custom_read_request(user_ble_master_handle, user_att_name_handle);
                ql_rtos_task_sleep_s(5);
                ble_demo_master_test_buf[0]++;
                ql_le_custom_write_request(user_ble_master_handle, user_att_name_handle, (uint8 *)ble_demo_master_test_buf, sizeof(ble_demo_master_test_buf));
                ql_rtos_task_sleep_ms(10);
            }
        }
#endif

#ifdef BLE_DEMO_SLAVE
        if (user_ble_slave_notify_flag == 1)
        {
            ble_demo_loop_test_buf[0]++;
            ql_appbt_le_notify(user_ble_slave_handle, ble_demo_loop_test_handle, (uint8_t *)ble_demo_loop_test_buf, sizeof(ble_demo_loop_test_buf));
            ql_rtos_task_sleep_s(5);
        }
#endif
        ql_rtos_task_sleep_s(5);
    }
}
//application_init(ql_bt_task_init, "ql_bt_task_init", 4, 0);