From: dxy <1731678236@qq.com>
Date: Wed, 28 Feb 2024 03:19:08 +0000 (+0800)
Subject: BtGattsRequestWriteCallback
X-Git-Tag: release_V1.2.70_20241020_135402~1299
X-Git-Url: http://git.snicker.com.cn/Users/apple/Desktop/static/gitweb.css?a=commitdiff_plain;h=bec8e2b26a5c3f618f5ffb27f3831888b920bdb0;p=mirrors%2FFD230.git

BtGattsRequestWriteCallback
---

diff --git a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c
index 2958163b0..673f35466 100755
--- a/code/sdk/application/brandy/brandy_standard/thread_pri_init.c
+++ b/code/sdk/application/brandy/brandy_standard/thread_pri_init.c
@@ -9,6 +9,7 @@
 #include "common_def.h"
 #include "pm.h"
 #include "watchdog.h"
+#include "bleService.h"
 /* after reboot system emmc need write exc info to the file system from sector */
 #if defined(SAVE_EXC_INFO) && defined(CFG_DRIVERS_MMC)
 #include "exception.h"
@@ -329,6 +330,9 @@ static void thread_main(const void *unused)
 #ifdef SUPPORT_ALIPAY_SEC
     uapi_alipay_svr_init();
 #endif
+
+    svr_bluetooth_init();
+
     set_startup_finish_flag();
 }
 
diff --git a/code/sdk/application/wearable/alipay/service/alipay_bluetooth.c b/code/sdk/application/wearable/alipay/service/alipay_bluetooth.c
index 685e0e811..e44664ceb 100644
--- a/code/sdk/application/wearable/alipay/service/alipay_bluetooth.c
+++ b/code/sdk/application/wearable/alipay/service/alipay_bluetooth.c
@@ -14,7 +14,7 @@
 #include "osal_task.h"
 #include "alipay_feature.h"
 #include "securec.h"
-
+#include "wearable_log.h"
 /* Gatt service UUID */
 #define ALIPAYY_SERVICE_ID 0x0238
 /* Gatt Characteristic UUID */
@@ -307,11 +307,11 @@ void svr_alipay_bt_gatts_noyify(uint8_t *data, uint16_t data_len)
 
 static void svr_alipay_btcallback_reg(void)
 {
-    g_alipay_gapble_cbs.conn_state_change_cb = svr_alipay_ble_connstate_change_cb;
-    g_alipay_gapble_cbs.start_adv_cb = svr_alipay_ble_adv_start_cb;
-    g_alipay_gapble_cbs.stop_adv_cb = svr_alipay_ble_adv_stop_cb;
-    g_alipay_gapble_cbs.set_adv_data_cb = svr_alipay_ble_set_adv_data_cb;
-    gap_ble_register_callbacks(&g_alipay_gapble_cbs);
+    // g_alipay_gapble_cbs.conn_state_change_cb = svr_alipay_ble_connstate_change_cb;
+    // g_alipay_gapble_cbs.start_adv_cb = svr_alipay_ble_adv_start_cb;
+    // g_alipay_gapble_cbs.stop_adv_cb = svr_alipay_ble_adv_stop_cb;
+    // g_alipay_gapble_cbs.set_adv_data_cb = svr_alipay_ble_set_adv_data_cb;
+    // gap_ble_register_callbacks(&g_alipay_gapble_cbs);
 
     g_alipay_gatts_cbs.add_service_cb = svr_alipay_bt_gatts_service_add_cb;
     g_alipay_gatts_cbs.add_characteristic_cb = svr_alipay_bt_gatts_characteristic_add_cb;
diff --git a/code/sdk/application/wearable/fd230app/nativeui/bluetooth/src/BluetoothModel.cpp b/code/sdk/application/wearable/fd230app/nativeui/bluetooth/src/BluetoothModel.cpp
index 381aaf79c..e0e7f72c8 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/bluetooth/src/BluetoothModel.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/bluetooth/src/BluetoothModel.cpp
@@ -59,8 +59,8 @@ void BluetoothModel::Init()
     bool ret = enable_bt_stack();
     WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "bt enable_bt_stack ret = %d", ret);
 
-    BtInitCallBacks();
-    BtInitGatts();
+    // BtInitCallBacks();
+    // BtInitGatts();
     BtInitSpp();
 
     SetUpListCase();
@@ -567,6 +567,8 @@ void BtGapDiscoveryResultCallback(const bd_addr_t *bdAddr)
                                                               BluetoothModel::GetInstance(), *bdAddr));
 }
 
+
+
 void HandleBeforeChangeView()
 {
     int curView = BluetoothModel::GetInstance()->GetCurView();
@@ -944,7 +946,7 @@ static void BtGattsRequestReadCallback(uint8_t serverId, uint16_t connId, gatts_
 
 static void BtGattsRequestWriteCallback(uint8_t serverId, uint16_t connId, gatts_req_write_cb_t *writeCbPara,  errcode_t status)
 {
-    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "BtGattsRequestWriteCallback");
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "BtGattsRequestWriteCallback333 %s %d",writeCbPara->value,writeCbPara->length);
 }
 
 // 注册回调函数
@@ -954,41 +956,43 @@ static gap_ble_callbacks_t g_gapBleCallbacks{};
 static gatts_callbacks_t g_btGattsCallbacks{};
 void BtInitCallBacks()
 {
-    g_btGapCallBacks.discovery_result_callback = BtGapDiscoveryResultCallback;
-    g_btGapCallBacks.discovery_state_changed_callback = BtGapDiscoveryStateChangedCallback;
-    g_btGapCallBacks.acl_state_changed_callbak = GapAclStateChangedCallback;
-    g_btGapCallBacks.read_remote_rssi_event_callback = BtGapReadRemoteRssiEventCallback;
-    g_btGapCallBacks.remote_name_changed_callback = BtRemoteNameChangedCallback;
-    g_btGapCallBacks.is_accept_conn_on_safe_mode_callback = BtIsAcceptConnOnSafeModeCallback;
-    g_btGapCallBacks.pair_status_changed_callback = BtGapPairStatusChangedCallback;
-    g_btGapCallBacks.pair_requested_callback = BtGapPairRequestedCallback;
-    g_btGapCallBacks.pair_confiremed_callback = BtGapPairConfirmedCallback;
-    gap_register_callbacks(&g_btGapCallBacks);
-
-    g_a2dpSrcCallbacks.connectstate_changed_cb = A2dpSrcConnectstateChanged;
-    g_a2dpSrcCallbacks.configuration_changed_cb = A2dpSrcConfigureChanged;
-    g_a2dpSrcCallbacks.playing_state_changed_cb = A2dpSrcPlayingStateChanged;
-    a2dp_src_register_callbacks(&g_a2dpSrcCallbacks);
-
-    g_gapBleCallbacks.conn_state_change_cb = BleConnStateChangeCallback;
-    g_gapBleCallbacks.start_adv_cb = BleAdvStartCallback;
-    g_gapBleCallbacks.stop_adv_cb = BleAdvStopCallback;
-    gap_ble_register_callbacks(&g_gapBleCallbacks);
-
-    g_btGattsCallbacks.add_service_cb = BtGattsServiceAddCallback;
-    g_btGattsCallbacks.add_characteristic_cb = BtGattsCharacteristicAddCallback;
-    g_btGattsCallbacks.add_descriptor_cb = BtGattsDescriptorAddCallback;
-    g_btGattsCallbacks.start_service_cb = BtGattsServiceStartCallback;
-    g_btGattsCallbacks.stop_service_cb = BtGattsServiceStopCallback;
-    g_btGattsCallbacks.delete_service_cb = BtGattsServiceDeleteCallback;
-    g_btGattsCallbacks.read_request_cb = BtGattsRequestReadCallback;
-    g_btGattsCallbacks.write_request_cb = BtGattsRequestWriteCallback;
-    g_btGattsCallbacks.mtu_changed_cb = NULL;
-    gatts_register_callbacks(&g_btGattsCallbacks);
+    // g_btGapCallBacks.discovery_result_callback = BtGapDiscoveryResultCallback;
+    // g_btGapCallBacks.discovery_state_changed_callback = BtGapDiscoveryStateChangedCallback;
+    // g_btGapCallBacks.acl_state_changed_callbak = GapAclStateChangedCallback;
+    // g_btGapCallBacks.read_remote_rssi_event_callback = BtGapReadRemoteRssiEventCallback;
+    // g_btGapCallBacks.remote_name_changed_callback = BtRemoteNameChangedCallback;
+    // g_btGapCallBacks.is_accept_conn_on_safe_mode_callback = BtIsAcceptConnOnSafeModeCallback;
+    // g_btGapCallBacks.pair_status_changed_callback = BtGapPairStatusChangedCallback;
+    // g_btGapCallBacks.pair_requested_callback = BtGapPairRequestedCallback;
+    // g_btGapCallBacks.pair_confiremed_callback = BtGapPairConfirmedCallback; 
+    
+    // gap_register_callbacks(&g_btGapCallBacks);
+
+    // g_a2dpSrcCallbacks.connectstate_changed_cb = A2dpSrcConnectstateChanged;
+    // g_a2dpSrcCallbacks.configuration_changed_cb = A2dpSrcConfigureChanged;
+    // g_a2dpSrcCallbacks.playing_state_changed_cb = A2dpSrcPlayingStateChanged;
+    // a2dp_src_register_callbacks(&g_a2dpSrcCallbacks);
+
+    // g_gapBleCallbacks.conn_state_change_cb = BleConnStateChangeCallback;
+    // g_gapBleCallbacks.start_adv_cb = BleAdvStartCallback;
+    // g_gapBleCallbacks.stop_adv_cb = BleAdvStopCallback;
+    // gap_ble_register_callbacks(&g_gapBleCallbacks);
+
+    // g_btGattsCallbacks.add_service_cb = BtGattsServiceAddCallback;
+    // g_btGattsCallbacks.add_characteristic_cb = BtGattsCharacteristicAddCallback;
+    // g_btGattsCallbacks.add_descriptor_cb = BtGattsDescriptorAddCallback;
+    // g_btGattsCallbacks.start_service_cb = BtGattsServiceStartCallback;
+    // g_btGattsCallbacks.stop_service_cb = BtGattsServiceStopCallback;
+    // g_btGattsCallbacks.delete_service_cb = BtGattsServiceDeleteCallback;
+    // g_btGattsCallbacks.read_request_cb = BtGattsRequestReadCallback;
+    // g_btGattsCallbacks.write_request_cb = BtGattsRequestWriteCallback;
+    // g_btGattsCallbacks.mtu_changed_cb = NULL;
+    // gatts_register_callbacks(&g_btGattsCallbacks);
 }
 
 void BtInitGatts(void)
 {
+    return;
     uint16_t id = 0x1FF0;
     uint16_t ser_id = 0x1FFF;
     uint8_t serverId = 0;
diff --git a/code/sdk/application/wearable/fd230app/nativeui/system/include/SystemView.h b/code/sdk/application/wearable/fd230app/nativeui/system/include/SystemView.h
index f02778015..998905fc7 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/system/include/SystemView.h
+++ b/code/sdk/application/wearable/fd230app/nativeui/system/include/SystemView.h
@@ -13,6 +13,8 @@
 #include "system/include/SystemSuperviseView.h"
 #include "system/include/SystemLanguageView.h"
 #include "system/include/SystemFactoryResetView.h"
+
+
 namespace OHOS
 {
     static const char *ABOUT_THE_WATCH = "AboutTheWatchButton";  // 关于手表
diff --git a/code/sdk/application/wearable/fd230app/nativeui/system/src/SystemView.cpp b/code/sdk/application/wearable/fd230app/nativeui/system/src/SystemView.cpp
index 85dc04cba..49f96d9da 100644
--- a/code/sdk/application/wearable/fd230app/nativeui/system/src/SystemView.cpp
+++ b/code/sdk/application/wearable/fd230app/nativeui/system/src/SystemView.cpp
@@ -1,6 +1,10 @@
 #include "system/include/SystemView.h"
 #include "system/include/SystemPresenter.h"
 #include "wearable_log.h"
+#include "bleService.h"
+#include "battery_hal.h"
+extern uint8_t battery_get_voltage(float *voltage);
+extern void openBle(void);
 namespace OHOS
 {
 
@@ -206,6 +210,7 @@ namespace OHOS
     {
         if (SystemScrollView[thisView] == nullptr)
         {
+            openBle();
             WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "SystemView::ChangeSystemAboutView");
             p_SystemAboutTheWatchView = new SystemAboutTheWatchView();
             if (p_SystemAboutTheWatchView == nullptr)
diff --git a/code/sdk/application/wearable/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp b/code/sdk/application/wearable/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp
index f7eeb073b..af7cbbfb3 100755
--- a/code/sdk/application/wearable/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp
+++ b/code/sdk/application/wearable/nativeapp/nativeui/bluetooth/src/BluetoothModel.cpp
@@ -23,6 +23,9 @@
 #include "bts_gatt_server.h"
 #include "bts_le_gap.h"
 #include "bts_spp.h"
+
+// #include "bleService.h"
+
 #include "osal_task.h"
 #ifdef SUPPORT_ALIPAY_SEC
 #include "alipay_feature.h"
@@ -33,6 +36,10 @@
 #include "bts_avrcp_target.h"
 
 namespace OHOS {
+#define BLE_SERVICE_UUID 0x18E0
+#define BLE_RX_UUID 0x2ae3
+#define BLE_TX_UUID 0x2ae5
+#define BLE_BAE_UUID  {0xfb,0x34,0x9b,0x5f,0x80,0x00,0x00,0x80,0x00,0x10,0x00,0x00,0xE3,0x2A,0x00,0x00}
 
 #define BT_SPP_TASK_STACK_SIZE 2048
 #define BT_SPP_TASK_PRI        20
@@ -76,10 +83,12 @@ void BluetoothModel::Init()
     BtInitCallBacks();
 #ifdef SUPPORT_ALIPAY_SEC
     svr_alipay_bluetooth_init();
-#else
+#endif
+
+    // svr_bluetooth_init();
     BtInitCallBacksEx();
     BtInitGatts();
-#endif
+
     BtInitSpp();
 
     SetUpListCase();
@@ -932,8 +941,8 @@ static void BtGattsServiceAddCallback(uint8_t serverId, bt_uuid_t *uuid, uint16_
     WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "BtGattsServiceAddCallback 0x%x 0x%x 0x%x",
         status, serverId, srvcHandle);
 
-    if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t*)uuid->uuid) == 0x1FF0)) {
-        uint16_t id = 0x1FF1;
+    if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t*)uuid->uuid) == BLE_SERVICE_UUID)) {
+        uint16_t id = BLE_RX_UUID;
         gatts_add_chara_info_t character;
         uint16_t value = 0;
 
@@ -941,12 +950,27 @@ static void BtGattsServiceAddCallback(uint8_t serverId, bt_uuid_t *uuid, uint16_
         character.chara_uuid.uuid_len = sizeof(id);
         memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
         character.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
-        character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE;
+        character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_READ |GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
         character.value_len = (uint16_t)sizeof(value);
         character.value = (uint8_t *)(&value);
 
         ret = gatts_add_characteristic(serverId, srvcHandle, &character);
         WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_add_characteristic ret 0x%x", ret);
+
+        uint16_t tx_uuid[16] = BLE_BAE_UUID;
+        gatts_add_chara_info_t txcharacter;
+        uint16_t txvalue = 0;
+
+        memset_s(&txcharacter, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        txcharacter.chara_uuid.uuid_len = sizeof(tx_uuid);
+        memcpy_s(txcharacter.chara_uuid.uuid, sizeof(txcharacter.chara_uuid.uuid), (char *)&tx_uuid, sizeof(tx_uuid));
+        txcharacter.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+        txcharacter.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_READ |GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
+        txcharacter.value_len = (uint16_t)sizeof(txvalue);
+        txcharacter.value = (uint8_t *)(&txvalue);
+
+        ret = gatts_add_characteristic(serverId, srvcHandle, &txcharacter);
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_add_characteristic ret 0x%x", ret);
     }
 }
 
@@ -989,7 +1013,7 @@ static void BtGattsRequestReadCallback(uint8_t serverId, uint16_t connId, gatts_
 
 static void BtGattsRequestWriteCallback(uint8_t serverId, uint16_t connId, gatts_req_write_cb_t *writeCbPara,  errcode_t status)
 {
-    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "BtGattsRequestWriteCallback");
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "BtGattsRequestWriteCallback2 %s length:%d",writeCbPara->value,writeCbPara->length);
 }
 
 static void BtA2dpSnkAcceptTimerStop(void)
@@ -1181,7 +1205,7 @@ void BtInitCallBacksEx()
 
 void BtInitGatts(void)
 {
-    uint16_t id = 0x1FF0;
+    uint16_t id = BLE_SERVICE_UUID;
     uint16_t ser_id = 0x1FFF;
     uint8_t serverId = 0;
     bt_uuid_t uuid;
diff --git a/code/sdk/application/wearable/service/CMakeLists.txt b/code/sdk/application/wearable/service/CMakeLists.txt
index dab7be79e..eec10d460 100755
--- a/code/sdk/application/wearable/service/CMakeLists.txt
+++ b/code/sdk/application/wearable/service/CMakeLists.txt
@@ -9,3 +9,4 @@ if("CONFIG_SEA_PHS_SUPPORT" IN_LIST DEFINES)
 endif()
 add_subdirectory_if_exist(power_manager)
 add_subdirectory_if_exist(timeservice)
+add_subdirectory_if_exist(ble_service)
diff --git a/code/sdk/application/wearable/service/ble_service/CMakeLists.txt b/code/sdk/application/wearable/service/ble_service/CMakeLists.txt
new file mode 100644
index 000000000..e6b612b72
--- /dev/null
+++ b/code/sdk/application/wearable/service/ble_service/CMakeLists.txt
@@ -0,0 +1,34 @@
+set(COMPONENT_NAME "ble_service")
+set(PUBLIC_HEADER
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+
+set(PRIVATE_HEADER
+
+)
+set(SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/bleService.c
+)
+
+set(COMPONENT_PUBLIC_CCFLAGS
+)
+
+set(COMPONENT_CCFLAGS
+)
+
+set(WHOLE_LINK
+    true
+)
+
+set(MAIN_COMPONENT
+    false
+)
+
+set(PUBLIC_DEFINES
+)
+
+set(PRIVATE_DEFINES
+)
+
+build_component()
diff --git a/code/sdk/application/wearable/service/ble_service/bleService.c b/code/sdk/application/wearable/service/ble_service/bleService.c
new file mode 100644
index 000000000..33aa72e2f
--- /dev/null
+++ b/code/sdk/application/wearable/service/ble_service/bleService.c
@@ -0,0 +1,862 @@
+/**
+ * Copyright (c) CompanyNameMagicTag 2023-2023. All rights reserved.
+ * Description: alipay bluetooth module.
+ * Author:
+ * Create:
+ */
+
+#include "common_def.h"
+#include "bts_def.h"
+#include "bts_gatt_stru.h"
+#include "bts_a2dp_source.h"
+#include "bts_gatt_server.h"
+#include "bts_le_gap.h"
+#include "osal_task.h"
+#include "securec.h"
+#include "wearable_log.h"
+#include <stdint.h>
+#include <stdio.h>
+#include "stdbool.h"
+/* Gatt service UUID */
+#include "bts_br_gap.h"
+#include "battery_hal.h"
+#include "bleService.h"
+
+#define BLE_SERVICE_UUID 0x18e0
+/* Gatt Characteristic UUID */
+#define BLE_CHARACTERISTIC_RECV_ID 0xe52a
+#define BLE_CHARACTERISTIC_SNED_SHORT_ID 0xe32a
+
+#define BLE_CHARACTERISTIC_SNED_LONG_ID 0xe42a
+#define BLE_CHARACTERISTIC_SNED_OTA_ID 0xe02a
+#define BLE_CHARACTERISTIC_SNED_ANDRIOD_ID 0xe12a
+#define BLE_CHARACTERISTIC_READ_BATTERY_ID 0xe22a
+/* Client Characteristic Configuration UUID */
+#define BLE_UUID_CLIENT_CHARACTERISTIC_CONF 0x2902
+/* Gatt Characteristic max length */
+#define BLE_CHARACTERISTIC_MAX_LENGTH 256
+#define BLE_ADV_ID 1
+#define BLE_ADV_DATA_MAX_LENGTH 31
+#define BLE_ADV_BLE_NAME_MAX_LENGTH 13 // 31-4-2-3-9 = 13
+#define BLE_NAME_LENGTH 32
+#define BLE_ADV_MAC_HEAD_LENTH 4
+#define BLE_ADV_MAC_LENTH 10
+#define BLE_SCAN_MAC_LENTH 16 //扫描数据
+#define BLE_ADV_TYPE_LENTH 3
+#define BLE_ADV_UUID_LENTH 4
+#define BLE_DEFAULT_NAME  "KUMI U6"
+#define BLE_DEFAULT_NAME_LEN 32
+#define BLE_MAC_MAX_LEN 6 //蓝牙mac地址最大个数6个
+//  蓝牙模块全局变量
+static gap_ble_callbacks_t g_ble_gapble_cbs;
+static gatts_callbacks_t g_ble_gatts_cbs;
+static gap_call_backs_t g_btGapCallBacks;
+static a2dp_src_callbacks_t g_a2dpSrcCallbacks;
+
+static bool g_ble_adv_start_state = false;
+static uint16_t g_ble_server_id = 1;
+static uint16_t g_ble_server_handle = 0;
+static uint16_t g_ble_conn_id = 0;
+static uint8_t g_ble_character_buf[BLE_CHARACTERISTIC_MAX_LENGTH] = {0};
+static bool g_ble_init_flag = false;
+static const uint8_t ble_adv_type[BLE_ADV_TYPE_LENTH] = {2, 1, 2};
+static const uint8_t ble_adv_uuid[BLE_ADV_UUID_LENTH] = {0x3, 0x3, 0xe0, 0x18};
+static bool AdverFlag = false;
+uint8_t Bleconnect = 0;//蓝牙默认是断开 0 1 为连接
+static uint8_t scan_data[BLE_SCAN_MAC_LENTH] = {0};
+enum{
+    BLE_CHARACTERISTIC_RECV_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_NOTIFY|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP|GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_READ,
+    BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES =  GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+    BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+    BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+    BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_WRITE|GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP,
+    BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES = GATT_CHARACTER_PROPERTY_BIT_READ,
+};
+
+static void svr_ble_ble_adv_stop(void)
+{
+    gap_ble_stop_adv(BLE_ADV_ID);
+}
+static void svr_ble_ble_adv_start(void)
+{
+    gap_ble_start_adv(BLE_ADV_ID);
+}
+/* adapt ios adv data. *///设置广播和扫描数据
+static void svr_ble_adv_data_set(int adv_id)
+{
+    uint8_t ble_name[BLE_NAME_LENGTH] = {0};
+    uint8_t ble_name_len = BLE_NAME_LENGTH;
+    uint8_t adv_data[BLE_ADV_DATA_MAX_LENGTH] = {0};
+    uint8_t adv_data_len = 0;
+    uint8_t scan_data_len = 0;
+    uint8_t ble_data_name[BLE_ADV_BLE_NAME_MAX_LENGTH + 1 ] = {0}; // +TYPE LENGTH
+    uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
+    uint8_t adv_mac_head[BLE_ADV_MAC_LENTH] = {0x9, 0x16, 0xe0, 0x18};
+    gap_ble_config_adv_data_t adv_data_info;
+    memset_s(&adv_data_info, sizeof(gap_ble_config_adv_data_t), 0, sizeof(gap_ble_config_adv_data_t));
+
+    
+    bd_addr_t addr_info;
+    int32_t ret= 0;
+    unsigned int len = BLE_MAC_MAX_LEN;
+    unsigned char addr[BLE_MAC_MAX_LEN] = {0};
+    bluetooth_get_local_addr(&addr[0],len);
+    // ret = gap_ble_get_local_addr(&addr_info);
+    char name[] = BLE_DEFAULT_NAME;
+
+    memset_s(name, sizeof(name), 0, sizeof(name));
+    (void)sprintf_s(name, sizeof(name), "0x%x0x%x",addr[0],addr[1]);
+    uint8_t name_len = strlen(name);
+    if (name_len > BLE_DEFAULT_NAME_LEN){
+        name_len = BLE_DEFAULT_NAME_LEN;
+    }
+    bluetooth_set_local_name((unsigned char*)name, name_len);//设置本地蓝牙名称
+
+    ret = bluetooth_get_local_name(ble_name, &ble_name_len);
+    if (ret != 0) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name fail, name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
+        memset_s(ble_name, BLE_NAME_LENGTH, 0, BLE_NAME_LENGTH);
+        memcpy_s(ble_name, BLE_NAME_LENGTH,BLE_DEFAULT_NAME, BLE_DEFAULT_NAME_LEN);
+        ble_name_len = BLE_DEFAULT_NAME_LEN + 1;        
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_name name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
+
+    ret = gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE, 60); // start scan
+    if (ret == false) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ConnectPhonePresenter bt gap_br_set_bt_scan_mode ret = 0x%x", ret);
+    }
+
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_get_local_addr, ret:%u.", ret);
+    memcpy_s(adv_data, sizeof(ble_adv_type), ble_adv_type, sizeof(ble_adv_type));
+    adv_data_len = sizeof(ble_adv_type);
+
+    if (ble_name_len > BLE_ADV_BLE_NAME_MAX_LENGTH) {
+        ble_name_len = BLE_ADV_BLE_NAME_MAX_LENGTH;
+    }
+    ble_data_name[0] = ble_name_len;
+    ble_data_name[1] = 0x9;
+    memcpy_s(&ble_data_name[2], ble_name_len - 1, ble_name, ble_name_len - 1);
+
+    memcpy_s(adv_data + adv_data_len, ble_name_len + 1, ble_data_name, ble_name_len + 1);
+
+    adv_data_len = adv_data_len + ble_name_len + 1;
+    memcpy_s(adv_data + adv_data_len, sizeof(ble_adv_uuid), ble_adv_uuid, sizeof(ble_adv_uuid));
+    adv_data_len = adv_data_len + sizeof(ble_adv_uuid);
+    int k = BD_ADDR_LEN;
+    for (int i = 0; i < BD_ADDR_LEN; i++) {
+        ble_data_mac_switch[--k] = addr[i];
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ble_info:%02x:%02x:%02x:%02x:%02x:%02x", ble_data_mac_switch[0], ble_data_mac_switch[1],
+        ble_data_mac_switch[2], ble_data_mac_switch[3], ble_data_mac_switch[4], ble_data_mac_switch[5]);
+    memcpy_s(adv_mac_head + BLE_ADV_MAC_HEAD_LENTH, BD_ADDR_LEN, ble_data_mac_switch, BD_ADDR_LEN);
+
+    memcpy_s(adv_data + adv_data_len, sizeof(adv_mac_head), adv_mac_head, sizeof(adv_mac_head));
+    adv_data_len = adv_data_len + sizeof(adv_mac_head);
+
+    scan_data[0] = 0x0f;//长度
+    scan_data[1] = 0xff;//数据类型 manufactory data
+    scan_data[2] = 'J';
+    scan_data[3] = 'H';
+    scan_data[4] = 0x00;
+    memcpy_s(scan_data+5,BD_ADDR_LEN, ble_data_mac_switch, BD_ADDR_LEN);//拷贝蓝牙设备地址到厂商数据里面做广播扫描使用,app会扫描这里做连接使用
+    // scan_data_len = strlen((char *)scan_data);//转换成char型
+    scan_data_len = 11;
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length.scan_data_len:%d\r\n",scan_data_len);
+    scan_data[scan_data_len++] = 0x05;//未知 app
+    scan_data[scan_data_len++] = 0x05;
+    scan_data[scan_data_len++] = 0x00;
+    scan_data[scan_data_len++] = 0x00;
+    scan_data[scan_data_len++] = 0x01;
+    
+    if (scan_data_len > BLE_SCAN_MAC_LENTH){
+        scan_data_len = BLE_SCAN_MAC_LENTH;
+    }
+    adv_data_info.scan_rsp_data = scan_data;//扫描数据
+    adv_data_info.scan_rsp_length = scan_data_len;//扫描长度
+    adv_data_info.adv_data = adv_data;//广播数据 
+    adv_data_info.adv_length = adv_data_len;//广播长度
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "adv_data_info.adv_length:%u. scan_data_len:%d\r\n", adv_data_len,scan_data_len);
+    gap_conn_param_update_t params;//更改连接参数
+    params.interval_min = 0x140;
+    params.interval_max = 0x200;
+    params.conn_handle = 1;
+    params.slave_latency = 0;
+    params.timeout_multiplier = 4000;
+    ret = gap_ble_connect_param_update(&params);
+    gap_ble_set_adv_data(adv_id, &adv_data_info);
+
+    return;
+}
+
+void svr_ble_adv_start(void)
+{
+    int adv_id = BLE_ADV_ID;
+    if (AdverFlag) { //已经开始广播了，不需要重复开启广播
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BleAdvStart already started1");
+        return;
+    }
+
+    gap_ble_adv_params_t adv_para;
+    memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
+
+    adv_para.min_interval = 0x140;
+    adv_para.max_interval = 0x200;
+    adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
+    adv_para.channel_map = 0x7;
+    adv_para.duration = 0;
+
+    gap_ble_set_adv_param(adv_id, &adv_para);//设置广播参数
+    gap_ble_set_local_appearance(GAP_BLE_APPEARANCE_TYPE_GENERIC_WATCH);//仅是手表
+    svr_ble_adv_data_set(adv_id);//开始广播和扫描数据
+    int32_t ret = gap_ble_start_adv(adv_id);
+    if (ret) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv1  ret = 0x%x", ret);
+    }
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start bt gap_ble_start_adv2  ret = 0x%x", ret);
+}
+
+static void svr_ble_connstate_change_cb(unsigned short conn_id, bd_addr_t *addr, gap_ble_conn_state_t conn_state,
+    gap_ble_pair_state_t pair_state, gap_ble_disc_reason_t disc_reason)
+
+{
+    // ALIPAY_PRINT_DEBUG(0, "BleConnStateChangeCallback conn_id 0x%x, conn_state 0x%x, pair_state 0x%x", conn_id,
+        // conn_state, pair_state);
+    g_ble_conn_id = conn_id;
+    if (GAP_BLE_STATE_DISCONNECTED == conn_state) { // restart ble adv when disconnected
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GAP_BLE_STATE_DISCONNECTED!!! 0x%x\r\n",pair_state);
+        Bleconnect = GAP_BLE_STATE_DISCONNECTED;//蓝牙已断开
+        if(AdverFlag != true){
+            svr_ble_adv_start();
+            svr_ble_ble_adv_start();
+        }    
+    } else {
+        Bleconnect = GAP_BLE_STATE_CONNECTED;//蓝牙已连接
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "GAP_BLE_STATE_CONNECTED!!! 0x%x\r\n",pair_state);
+        
+    }
+}
+static void svr_pair_result_cbt_cb(uint16_t conn_id, const bd_addr_t *addr, errcode_t status)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_pair_result_cbt_cb!!! 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x status:0x%x\r\n",addr->addr[0],status);
+}
+static void svr_ble_adv_start_cb(uint8_t adv_id, adv_status_t status)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_start_cb!!! 0x%x %d",adv_id,status);
+    
+}
+
+static void svr_ble_set_adv_data_cb(uint8_t adv_id, errcode_t status)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_set_adv_data_cb:%d",status);
+   
+}
+
+static void svr_ble_adv_stop_cb(uint8_t adv_id, adv_status_t status)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_adv_stop_cb:%d",status);
+}
+
+static void svr_ble_bt_gatts_service_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
+    errcode_t status)
+{
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceAddCallback 0x%x 0x%x 0x%x 0x%x", status, server_id, srv_handle,
+        // *((uint16_t *)uuid->uuid));
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_service_add_cb 0x%x\r\n",srv_handle);
+    if (status != ERRCODE_BT_SUCCESS)
+    {
+        return;
+    }
+    int ret;
+    if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == 0xe018)) {
+        uint16_t id = 0 ;
+        gatts_add_chara_info_t character;
+        uint16_t value = 0;
+        gatts_add_character_result_t result = {0};
+
+        id = BLE_CHARACTERISTIC_SNED_OTA_ID;//ota特征值
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+        character.properties = BLE_CHARACTERISTIC_SNED_OTA_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+
+        id = BLE_CHARACTERISTIC_SNED_ANDRIOD_ID;//andriod特征值
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_READ;
+        character.properties = BLE_CHARACTERISTIC_SNED_ANDRIOD_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+
+        id = BLE_CHARACTERISTIC_READ_BATTERY_ID;//读取电量特征值
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_WRITE;
+        character.properties = BLE_CHARACTERISTIC_READ_BATTERY_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+
+        id = BLE_CHARACTERISTIC_SNED_SHORT_ID;
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+        character.properties = BLE_CHARACTERISTIC_SNED_SHORT_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+
+        id = BLE_CHARACTERISTIC_SNED_LONG_ID;
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+        character.properties = BLE_CHARACTERISTIC_SNED_LONG_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+
+        id = BLE_CHARACTERISTIC_RECV_ID;
+        memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
+        character.chara_uuid.uuid_len = sizeof(id);
+        memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
+        character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+        character.properties = BLE_CHARACTERISTIC_RECV_ID_PROPERTIES;
+        character.value_len = BLE_CHARACTERISTIC_MAX_LENGTH;
+        character.value = g_ble_character_buf;
+        ret = gatts_add_characteristic(server_id, srv_handle, &character);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_characteristic fail, ret:%u.\r\n", ret);
+        }
+       
+    }
+}
+static void svr_ble_bt_gatts_characteristic_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
+    gatts_add_character_result_t *result, errcode_t status)
+{
+     WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "bt_gatts_characteristic_add_cb 0x%x 0x%x 0x%x\r\n",srv_handle,result->handle,result->value_handle);
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsCharacteristicAddCallback 0x%x 0x%x 0x%x 0x%x 0x%x", status, server_id, srv_handle,
+        // result->handle, result->value_handle);
+
+    g_ble_server_handle = result->value_handle;
+    int ret = 0;
+    unsigned char byte1 = uuid->uuid[0]; // 第一个字节
+    unsigned char byte2 = uuid->uuid[1]; // 第二个字节
+    int tmpValue = (byte2 << 8) | byte1;
+    uint8_t bas_ccc_val=0;
+    bt_uuid_t ccc_uuid = {0};
+    gatts_add_desc_info_t descriptor;
+    
+    if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_SNED_OTA_ID)) {
+        memset(&descriptor,0,sizeof(gatts_add_desc_info_t));
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuis1");
+        bts_data_to_uuid_len2(0x2902, &ccc_uuid);
+        descriptor.desc_uuid = ccc_uuid;
+        descriptor.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
+        descriptor.value = &bas_ccc_val;
+        
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+        memset(&descriptor,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor.desc_uuid = ccc_uuid;
+        descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
+        descriptor.value = bas_ccc_val;
+        uint16_t handle;
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor second fail, ret:%u.\r\n", ret);
+        }
+        ret = gatts_start_service(server_id, srv_handle);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_start_service fail, ret:%u.\r\n", ret);
+        }
+    }
+    else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_SNED_ANDRIOD_ID)) {
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuid2");
+        gatts_add_desc_info_t descriptor_and;
+        uint8_t and_ccc_val=1;
+        memset(&descriptor_and,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor_and.desc_uuid = ccc_uuid;
+        descriptor_and.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor_and.value_len = (uint16_t)sizeof(and_ccc_val);
+        descriptor_and.value = &and_ccc_val;
+        uint16_t handle;
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_and);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+        
+    }
+    else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_READ_BATTERY_ID)) {
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuid3");
+        gatts_add_desc_info_t descriptor_bat;
+        uint8_t read_ccc_val=2;
+        memset(&descriptor_bat,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor_bat.desc_uuid = ccc_uuid;
+        descriptor_bat.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor_bat.value_len = (uint16_t)sizeof(read_ccc_val);
+        descriptor_bat.value = &read_ccc_val;
+         uint16_t handle;
+        // ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_recv);
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_bat);
+        // ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_bat);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+    }
+
+    else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_SNED_SHORT_ID)) {
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuid4");
+        gatts_add_desc_info_t descriptor_short;
+        uint8_t short_ccc_val=3;
+        memset(&descriptor_short,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor_short.desc_uuid = ccc_uuid;
+        descriptor_short.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor_short.value_len = (uint16_t)sizeof(short_ccc_val);
+        descriptor_short.value = &short_ccc_val;
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_short);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+        
+    }
+    else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_SNED_LONG_ID)) {
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuid5");
+        gatts_add_desc_info_t descriptor_long;
+        uint8_t long_ccc_val=4;
+        memset(&descriptor_long,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor_long.desc_uuid = ccc_uuid;
+        descriptor_long.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE;
+        descriptor_long.value_len = (uint16_t)sizeof(long_ccc_val);
+        descriptor_long.value = &long_ccc_val;
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_long);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+    }
+    else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_CHARACTERISTIC_RECV_ID)) {
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "mergedValue uuid6");
+        gatts_add_desc_info_t descriptor_recv;
+        uint8_t recv_ccc_val=5;
+        memset(&descriptor_recv,0,sizeof(gatts_add_desc_info_t));
+        bts_data_to_uuid_len2(0x2901, &ccc_uuid);
+        descriptor_recv.desc_uuid = ccc_uuid;
+        descriptor_recv.permissions =  GATT_ATTRIBUTE_PERMISSION_WRITE; 
+        descriptor_recv.value_len = (uint16_t)sizeof(recv_ccc_val);
+        descriptor_recv.value = &recv_ccc_val;
+        ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_recv);
+        if (ret != ERRCODE_SUCC) {
+            // ALIPAY_PRINT_ERR(0, "gatts_add_descriptor fail, ret:%u.\r\n", ret);
+        }
+        
+    }
+}
+
+static void svr_ble_bt_gatts_descriptor_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
+    uint16_t desc_handle, errcode_t status)
+{
+    
+}
+
+static void svr_ble_bt_gatts_service_start_cb(uint8_t server_id, uint16_t srv_handle, errcode_t status)
+{
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceStartCallback 0x%x 0x%x 0x%x", status, server_id, srv_handle);
+}
+
+static void svr_ble_bt_gatts_service_stop_cb(uint8_t server_id, uint16_t srv_handle, errcode_t status)
+{
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceStopCallback 0x%x 0x%x 0x%x", status, server_id, srv_handle);
+}
+
+static void svr_ble_bt_gatts_service_del_cb(uint8_t server_id, errcode_t status)
+{
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsServiceDeleteCallback 0x%x 0x%x", status, server_id);
+}
+static void svr_ble_bt_gatts_noyify(uint8_t *data, uint16_t data_len)//这里是设备数据上报给app手机端
+{
+    gatts_ntf_ind_t data_info;
+    data_info.attr_handle = g_ble_server_handle;
+    data_info.value = data;
+    data_info.value_len = data_len;
+    errcode_t ret = gatts_notify_indicate(g_ble_server_id, g_ble_conn_id, &data_info);
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.", ret, g_ble_server_id,
+        g_ble_conn_id, g_ble_server_handle);
+    
+    
+}
+static void svr_ble_bt_gatts_req_read_cb(uint8_t server_id, uint16_t conn_id, gatts_req_read_cb_t *read_cb_para,
+    errcode_t status)
+{
+    closeBle();
+    return;
+    //读取手表信息返回给手机app端
+    uint8_t battery_value[20];
+    memset(battery_value,0,20);
+    // 获取电池电压值
+    float voltage = 0.0F;
+    uint8_t power = 0;
+    power = battery_get_voltage(&voltage);
+    battery_value[0] = power;//电量90
+    uint16_t dial = 1;
+    battery_value[1] = 0;//当前表盘几
+    battery_value[2] = 1;
+
+    battery_value[3] = 0;//固件版本号
+    battery_value[4] = 0;
+    battery_value[5] = 1;
+
+    bd_addr_t addr_info;
+    int32_t ret= 0;
+    ret = gap_ble_get_local_addr(&addr_info);
+    battery_value[6] = addr_info.addr[5];
+    battery_value[7] = addr_info.addr[4];
+    battery_value[8] = addr_info.addr[3];
+    battery_value[9] = addr_info.addr[2];
+    battery_value[10] = addr_info.addr[1];
+    battery_value[11] = addr_info.addr[0];
+
+    battery_value[12] = 0;//消息推送开关 默认是关闭 0
+    battery_value[13] = 0;//多媒体开关
+    battery_value[14] = 5;//客户编号
+    battery_value[15] = 5;//产品编号
+
+    battery_value[16] = 0;//硬件版本号
+    battery_value[17] = 1;
+
+    battery_value[18] = 0;//ble版本号
+    battery_value[19] = 1;
+
+    svr_ble_bt_gatts_noyify(battery_value,20);
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_ble_bt_gatts_req_read_cb ret:is_long:%d",read_cb_para->is_long);
+    // ALIPAY_PRINT_DEBUG(0, "BtGattsRequestReadCallback");
+}
+
+static bool Check_CRC(uint8_t *crcnum,uint8_t len)//计算20byte的的校验位
+{
+	uint8_t crcbuf  = 0;
+	for(int i = 0; i < len-1; i++)
+	{
+		crcbuf += crcnum[i]; 
+    }
+	crcbuf = crcbuf&0xFF;
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "Check_CRC ret:0x%x\r\n",crcbuf);
+	if(crcbuf == crcnum[len-1])
+	    return true;
+	else
+		return false;
+}
+static void svr_ble_bt_gatts_req_write_cb(uint8_t server_id, uint16_t conn_id, gatts_req_write_cb_t *write_cb_para,
+    errcode_t status)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "server_id:%d write_cb_para %d %x %x\r\n",server_id,write_cb_para->length,write_cb_para->value[0],write_cb_para->value[1]);
+    uint8_t value[20];
+    memset(value,0,20);
+    value[0] = 0x72;
+    value[1] = 0x05;
+    value[2] = 0x11;
+    uint8_t tmp = 1;
+    memcpy(value+3,&tmp,4);
+    memcpy(value+7,&tmp,4);
+    memcpy(value+11,&tmp,4);
+    memcpy(value+15,&tmp,2);
+    value[18] = 0x01;
+    value[19] = 0x8d;
+    if(Check_CRC(value,20))
+    {   
+        // memcpy(write_cb_para->value,value,20);
+        // write_cb_para->length = 20;
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gatts_req_write_cb");
+        svr_ble_bt_gatts_noyify(value,20);
+    }
+    
+   
+   
+}
+static void svr_gap_ble_connect_param_update_callback(uint16_t conn_id, errcode_t status,const gap_ble_conn_param_update_t *param)
+{
+    WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "gap_ble_connect_param_update_callback %d %d %d\r\n",param->interval,param->latency,param->timeout);
+}
+// 回调： gap_read_remote_rssi_value 接口的数据上报
+static void svr_gap_ble_ReadRemoteRssiEventCallback(const bd_addr_t *bdAddr, int rssi, int status)
+{
+    UNUSED(status);
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapReadRemoteRssiEventCallback addr: %02x%02x%02x%02x%02x%02x",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* mac下标 0 1 2 3 4 5 */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* mac下标 0 1 2 3 4 5 */
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bt BtGapReadRemoteRssiEventCallback SetSortCaseRssi: %d status: %d", rssi, status);
+}
+
+// 回调：发现状态变化上报/扫描结束
+static void svr_gap_ble_DiscoveryStateChangedCallback(int status)
+{
+    UNUSED(status);
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bt BtGapDiscoveryStateChangedCallback %d", status);
+}
+
+
+static void svr_gap_ble_PairStatusChangedCallback(const bd_addr_t *bdAddr, int status)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapPairStatusChangedCallback addr: ****%02x%02x%02x%02x status: %d\n",
+        bdAddr->addr[3], bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], status); /* addr下标 0 1 2 3 */
+    if (status == GAP_PAIR_PAIRED) {
+       
+    }
+}
+
+static void svr_gap_ble_RequestedCallback(const bd_addr_t *bdAddr)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapPairRequestedCallback addr: ****%02x%02x%02x%02x\n",
+        bdAddr->addr[3], bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* addr下标 0 1 2 3 */
+}
+
+static void svr_gap_ble_ConfirmedCallback(const bd_addr_t *bdAddr, int req_type, int number)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapPairConfirmedCallback addr: ****%02x%02x%02x%02x req_type: %d number: %d\n",
+        bdAddr->addr[3], bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], /* addr下标 0 1 2 3 */
+        req_type, number);
+}
+
+// 回调：扫描结果处理/发现结果上报
+static void svr_gap_ble_DiscoveryResultCallback(const bd_addr_t *bdAddr)
+{
+    // if ((gap_get_device_class(bdAddr) & 0x200) != 0) {
+    //     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapDiscoveryResultCallback: Mobile Phone Device");
+    //     return;
+    // }
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtGapDiscoveryResultCallback");
+    if (bdAddr == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "addr nullptr");
+        return;
+    }
+}
+
+// 回调：ACL连接状态上报
+static void svr_gap_ble_AclStateChangedCallback(const bd_addr_t *bdAddr, gap_acl_state_t state, unsigned int reason)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "bt GapAclStateChangedCallback state %d, reason %x succ or err", state, reason);
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "addr: %02x%02x%02x%02x%02x%02x",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* mac下标 0 1 2 3 4 5 */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* mac下标 0 1 2 3 4 5 */
+    if ((gap_get_device_class(bdAddr) & 0x200) != 0) {
+        WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "GapAclStateChangedCallback: Mobile Phone Device");
+        return;
+    }
+}
+// 回调：远端设备名称变化
+static void svr_gap_ble_RemoteNameChangedCallback(const bd_addr_t *bdAddr, const unsigned char *deviceName, unsigned char length)
+{
+    // if ((gap_get_device_class(bdAddr) & 0x200) != 0) {
+    //     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtRemoteNameChangedCallback: Mobile Phone Device");
+    //     return;
+    // }
+    if (bdAddr == NULL) {
+        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "BtRemoteNameChangedCallback addr nullptr");
+        return;
+    }
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtRemoteNameChangedCallback addr: %02x%02x%02x%02x%02x%02x",
+                  bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* mac下标 0 1 2 3 4 5 */
+                  bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* mac下标 0 1 2 3 4 5 */
+
+}
+
+static void svr_gap_ble_IsAcceptConnOnSafeModeCallback(const bd_addr_t *bdAddr, bool *res)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "BtIsAcceptConnOnSafeModeCallback addr: %02x%02x%02x%02x%02x%02x set *res true",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* addr下标 3 4 5 */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* addr下标 0 1 2 */
+    *res = true;
+}
+
+static void A2dp_SrcConnectstateChanged(bd_addr_t *bdAddr, int connState)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "a2dp_src_connectStateChangedCallback addr: %02x%02x%02x%02x%02x%02x connState: %x",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], connState); /* 2 1 0 idx */
+    // if ((gap_get_device_class(bdAddr) & 0x200) != 0) {
+    //     WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "a2dp_src_connectstateChangedCb: Mobile Phone Device");
+    //     return;
+    // }
+    if (connState == PROFILE_STATE_CONNECTED) {
+        avrcp_ct_connect(bdAddr);
+        // PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_CONNECTED);
+    }
+
+    if (connState == PROFILE_STATE_DISCONNECTED) {
+        // PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_DISCONNECTED);
+    }
+}
+
+static void A2dp_SrcPlayingStateChanged(bd_addr_t *bdAddr, int playState)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "A2dpSrcPlayingStateChangedCallback addr: %02x%02x%02x%02x%02x%02x playState: %x",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], playState); /* 2 1 0 idx */
+}
+
+static void A2dp_SrcConfigureChanged(bd_addr_t *bdAddr, a2dp_codec_info_t *info)
+{
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "A2dpSrcConfigurationChangedCallback addr: %02x%02x%02x%02x%02x%02x ",
+        bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
+        bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* 2 1 0 idx */
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "codec_priority: %04x codec_type: %04x sample_rate: %02x bits_per_sample: %02x channel_mode: %02x ",
+        info->codec_priority, info->codec_type, info->sample_rate, info->bits_per_sample, info->channel_mode);
+    WEARABLE_LOGD(WEARABLE_LOG_MODULE_APP, "codec_specific1: %04x codec_specific2: %04x codec_specific3: %04x codec_specific4: %04x",
+        info->codec_specific1, info->codec_specific2, info->codec_specific3, info->codec_specific4);
+}
+
+
+static void svr_ble_btcallback_reg(void)//ble基础通讯服务注册回调函数
+{
+    gap_ble_sec_params_t sec_params = { 0 };
+    sec_params.bondable = 0x01;
+    sec_params.io_capability = GAP_BLE_IO_CAPABILITY_NOINPUTNOOUTPUT;//最好选择没有输入输出IO能力
+    sec_params.sc_enable = 0x00;
+    sec_params.sc_mode = GAP_BLE_GAP_SECURITY_MODE1_LEVEL2;
+    errcode_t ret = gap_ble_set_sec_param(&sec_params);//设置配对参数 发起配对弹窗
+
+    g_btGapCallBacks.discovery_result_callback = svr_gap_ble_DiscoveryResultCallback;
+    g_btGapCallBacks.discovery_state_changed_callback = svr_gap_ble_DiscoveryStateChangedCallback;
+    g_btGapCallBacks.acl_state_changed_callbak = svr_gap_ble_AclStateChangedCallback;
+    g_btGapCallBacks.read_remote_rssi_event_callback = svr_gap_ble_ReadRemoteRssiEventCallback;
+    g_btGapCallBacks.remote_name_changed_callback = svr_gap_ble_RemoteNameChangedCallback;
+    g_btGapCallBacks.is_accept_conn_on_safe_mode_callback = svr_gap_ble_IsAcceptConnOnSafeModeCallback;
+    g_btGapCallBacks.pair_status_changed_callback = svr_gap_ble_PairStatusChangedCallback;
+    g_btGapCallBacks.pair_requested_callback = svr_gap_ble_RequestedCallback;
+    g_btGapCallBacks.pair_confiremed_callback = svr_gap_ble_ConfirmedCallback; 
+    
+    gap_register_callbacks(&g_btGapCallBacks);
+
+    g_a2dpSrcCallbacks.connectstate_changed_cb = A2dp_SrcConnectstateChanged;
+    g_a2dpSrcCallbacks.configuration_changed_cb = A2dp_SrcConfigureChanged;
+    g_a2dpSrcCallbacks.playing_state_changed_cb = A2dp_SrcPlayingStateChanged;
+    a2dp_src_register_callbacks(&g_a2dpSrcCallbacks);
+
+
+    g_ble_gapble_cbs.conn_state_change_cb = svr_ble_connstate_change_cb;
+    g_ble_gapble_cbs.start_adv_cb = svr_ble_adv_start_cb;
+    g_ble_gapble_cbs.stop_adv_cb = svr_ble_adv_stop_cb;
+    g_ble_gapble_cbs.set_adv_data_cb = svr_ble_set_adv_data_cb;
+    g_ble_gapble_cbs.pair_result_cb = svr_pair_result_cbt_cb;
+    g_ble_gapble_cbs.conn_param_update_cb = svr_gap_ble_connect_param_update_callback;
+
+    gap_ble_register_callbacks(&g_ble_gapble_cbs);
+
+    g_ble_gatts_cbs.add_service_cb = svr_ble_bt_gatts_service_add_cb;
+    g_ble_gatts_cbs.add_characteristic_cb = svr_ble_bt_gatts_characteristic_add_cb;
+    g_ble_gatts_cbs.add_descriptor_cb = svr_ble_bt_gatts_descriptor_add_cb;
+    g_ble_gatts_cbs.start_service_cb = svr_ble_bt_gatts_service_start_cb;
+    g_ble_gatts_cbs.stop_service_cb = svr_ble_bt_gatts_service_stop_cb;
+    g_ble_gatts_cbs.delete_service_cb = svr_ble_bt_gatts_service_del_cb;
+    g_ble_gatts_cbs.read_request_cb = svr_ble_bt_gatts_req_read_cb;
+    g_ble_gatts_cbs.write_request_cb = svr_ble_bt_gatts_req_write_cb;
+    g_ble_gatts_cbs.mtu_changed_cb = NULL;
+    gatts_register_callbacks(&g_ble_gatts_cbs);
+}
+
+static void svr_ble_bt_init_gatts(void)
+{
+    uint16_t id = 0xe018;
+    uint16_t ser_id = 0x1fff;
+    uint8_t serverId = 0;
+    bt_uuid_t uuid;
+    int ret;
+    // static char server_app_uuid_for_test[] = {0x00,0x00,0xFE,0xE7,0x00,0x00,0x10,0x00,0x80,0x00,0x00,0x80,0x5F,0x9B,0x34,0xFB};//{0xfb,0x34,0x9b,0x5f,0x80,0x00,0x00,0x80,0x00,0x10,0x00,0x00,0xe7,0xfe,0x00,0x00};
+    uuid.uuid_len = (uint8_t)sizeof(ser_id);
+    memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&ser_id, sizeof(ser_id));
+    ret = gatts_register_server(&uuid, &serverId); /* 注册gatt server */
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_register_server ret: 0x%x serverId = 0x%x uuid.uuid_len:%d", ret, serverId,uuid.uuid_len);
+    g_ble_server_id = serverId;
+    
+    uuid.uuid_len = sizeof(id);
+    memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&id, sizeof(id));
+    ret = gatts_add_service(serverId, &uuid, true);
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "gatts_add_service ret: 0x%x", ret);
+    return;
+}
+
+
+
+
+void svr_bluetooth_init(void)
+{
+    // WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_bluetooth_init!!!!!!!!!!!!!!\r\n");
+    bool ret = enable_bt_stack();
+    if (ret != ERRCODE_SUCC) {
+        // WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_bluetooth_init enable_bt_stack ret:%u.\r\n", ret);
+    }
+    if (g_ble_init_flag == true) {
+        return;
+    }
+
+    svr_ble_btcallback_reg();
+    svr_ble_adv_start();
+    svr_ble_bt_init_gatts();
+    
+    g_ble_init_flag = true;
+    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "svr_bluetooth_init22222222222\r\n");
+    return;
+}
+//关闭蓝牙
+void closeBle(void)
+{
+    if(AdverFlag == false)//没有连接的状态下关闭蓝牙#只能手动开启蓝牙
+    {
+        AdverFlag = true;
+        g_ble_init_flag = false;
+        bd_addr_t bd_addr;
+        unsigned char addr[BLE_MAC_MAX_LEN] = {0};
+        bluetooth_get_local_addr(&addr[0],BD_ADDR_LEN);
+        memcpy(bd_addr.addr,addr,BLE_MAC_MAX_LEN);
+        errcode_t ret = 0;
+        if(Bleconnect == GAP_BLE_STATE_CONNECTED){//设备连接需要断开
+            ret = gap_ble_disconnect_remote_device((const bd_addr_t *)&bd_addr);//与固定的mac设置地址进行断开连接
+        }
+        svr_ble_ble_adv_stop();//停止广播 不发送广播数据 就是app搜索不到该设备了
+        ret = disable_ble();//关闭ble 直接断开和当前连接的手机app
+        WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "closeBle ret%d 0x%x-0x%x-0x%x-0x%x-0x%x-0x%x\r\n",ret,bd_addr.addr[0],bd_addr.addr[1],bd_addr.addr[2],bd_addr.addr[3],bd_addr.addr[4],bd_addr.addr[5]);
+    }
+}
+//开启蓝牙
+void openBle(void)
+{
+    if(AdverFlag == true)//在连接的状态下不需要
+    {
+        AdverFlag = false;
+        bool ret = enable_ble();//开启ble 直接断开和当前连接的手机app
+        svr_bluetooth_init();
+    }
+}
\ No newline at end of file
diff --git a/code/sdk/application/wearable/service/ble_service/bleService.h b/code/sdk/application/wearable/service/ble_service/bleService.h
new file mode 100644
index 000000000..77cf6dc70
--- /dev/null
+++ b/code/sdk/application/wearable/service/ble_service/bleService.h
@@ -0,0 +1,12 @@
+#ifndef BLESERVICE_H
+#define BLESERVICE_H
+#include <stdint.h>
+#include <stdio.h>
+#include "stdbool.h"
+
+void svr_bluetooth_init(void);//蓝牙服务初始化
+void closeBle(void);//主动关闭蓝牙
+void openBle(void);//主动开启蓝牙
+void svr_ble_adv_start(void);//开始蓝牙广播
+#endif
+
diff --git a/code/sdk/application/wstp/at_service/bt/bt_manager_at_process.c b/code/sdk/application/wstp/at_service/bt/bt_manager_at_process.c
index b7600d0cb..4071d4a49 100755
--- a/code/sdk/application/wstp/at_service/bt/bt_manager_at_process.c
+++ b/code/sdk/application/wstp/at_service/bt/bt_manager_at_process.c
@@ -27,7 +27,6 @@
 #include "bt_manager_tx_process.h"
 #include "bts_br_gap.h"
 #include "bt_manager_at_process.h"
-
 #define BSP_MEM_ALLOC(y) osal_kmalloc((y), OSAL_GFP_KERNEL)
 #define BSP_MEM_FREE(y) osal_kfree(y)
 #define ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))
@@ -1023,7 +1022,7 @@ uint32_t btsrv_wstp_at_enable_bt(const bt_manager_commu_inter_info_t *at_para)
 #if defined(SW_UART_DEBUG) || defined(SW_RTT_DEBUG)
     btsrv_set_log_type_level(BTSRV_LOG_UART_INFO);
 #endif
-    btsrv_at_cmd_gap_register_callbacks();
+    // btsrv_at_cmd_gap_register_callbacks();
 #ifdef SUPPORT_BREDR
     wstp_a2dp_src_register_callbacks();
     wstp_a2dp_snk_register_callbacks();
diff --git a/code/sdk/build/config/target_config/brandy/config.py b/code/sdk/build/config/target_config/brandy/config.py
index 7e5b01abb..1c2e22b79 100755
--- a/code/sdk/build/config/target_config/brandy/config.py
+++ b/code/sdk/build/config/target_config/brandy/config.py
@@ -128,7 +128,7 @@ target = {
                     'ENABLE_SHAPING',
                     'TPTYPE_FT6X46',
                     'SUPPORT_CHARGER_PLUG_DETECTION_NOTIFICATION', 
-                    'SUPPORT_ALIPAY_SEC'
+                    # 'SUPPORT_ALIPAY_SEC'
                     ],
         'ram_component': ["algorithm", "dfx_port_brandy", "dfx_update", 'dfx_nv', "osal", "arch_port", "-:testsuite",
                           "liteos_port", 'lcd', 'qspi_display', 'dfx_file_operation',
@@ -155,7 +155,8 @@ target = {
                           "rotary_encoder",
                           #"nativelauncher",
                            "fd230launcher",
-                          "batterry_service"
+                          "batterry_service",
+                          "ble_service"
 						  ],
         'ram_component_set': ['bgh', 'media', 'gpu', 'graphic_uikit', 'bgh_audio', 'dfx_set', 'ohos_set', 'wearable_set', 'alipay_set'],
         'dsp_version': 'max',
diff --git a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_bas_client.h b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_bas_client.h
index e4fe27e7f..bb4ebad38 100755
--- a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_bas_client.h
+++ b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_bas_client.h
@@ -401,4 +401,4 @@ void ble_bas_client_notify_characteristic_cbk(uint8_t client_id, uint16_t conn_i
 #ifdef __cplusplus
 }
 #endif
-#endif
\ No newline at end of file
+#endif
diff --git a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_hid_take_photo_server.h b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_hid_take_photo_server.h
index f35a0b72c..09a488b51 100755
--- a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_hid_take_photo_server.h
+++ b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/include/ble_hid_take_photo_server.h
@@ -18,7 +18,7 @@ extern "C" {
 #endif
 
 /* Human Interface Device UUID */
-#define BLE_UUID_HUMAN_INTERFACE_DEVICE 0x1812
+#define BLE_UUID_HUMAN_INTERFACE_DEVICE 0x18e2
 /* HID Information UUID */
 #define BLE_UUID_HID_INFORMATION 0x2A4A
 /* Report Map UUID */
diff --git a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/src/dis_profile_server.c b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/src/dis_profile_server.c
index bbbbd56fa..0d445f76a 100755
--- a/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/src/dis_profile_server.c
+++ b/code/sdk/protocol/bt/host/bt/bts/bt_sample/ble_profile/profiles/src/dis_profile_server.c
@@ -144,7 +144,7 @@ static void ble_pro_dis_add_character_system_id(uint8_t server_id, uint16_t srvc
 {
     size_t len = 0;
     if (g_ble_pro_dis_data.system_id == NULL) {
-        bts_error("dis server system id is not support!\r\n");
+        bts_error("dis server system id is not cd!\r\n");
         return;
     }
     len = strlen(g_ble_pro_dis_data.system_id) + 1;
diff --git a/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_core/sample_bts_gatt.c b/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_core/sample_bts_gatt.c
index f1c4921da..33b445b4e 100755
--- a/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_core/sample_bts_gatt.c
+++ b/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_core/sample_bts_gatt.c
@@ -1298,6 +1298,7 @@ static void sample_gatt_cmd_ble_set_local_name(const char **params, int32_t para
 
     const uint8_t *name = (const uint8_t *)params[0];
     uint8_t len = (uint8_t)atoi(params[1]);
+    bts_sample_log("gap ble set local name name: %s %d\n", name,len);
     errcode_t ret = gap_ble_set_local_name(name, len);
     bts_sample_log("gap ble set local name ret(errcode_t): %x\n", ret);
 }
diff --git a/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_srv_shell.c b/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_srv_shell.c
index 5304e5b80..cb15dc7c6 100755
--- a/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_srv_shell.c
+++ b/code/sdk/protocol/bt/host/bt/bts/bt_sample/bt_srv_shell.c
@@ -61,6 +61,7 @@ typedef enum {
 #if (BTH_LE_ONLY == YES) || (BTH_BREDR_LE_DOUBLE == YES)
 static void ble_service_sample_cmd(int32_t module_id, int32_t cmd_id, char **params, int32_t params_num)
 {
+    
     if (params == NULL) {
         return;
     }