2 * Open Adaptation Layer (OAL)
4 * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <bluetooth.h>
22 #include "oal-event.h"
23 #include "oal-internal.h"
24 #include "oal-manager.h"
25 #include "oal-adapter-mgr.h"
26 #include "oal-utils.h"
28 #include "oal-common.h"
30 #define DEV_APPEARANCE 0x0000
31 #define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
32 #define MAX_PROP_LEN 95 /* SVACE WGID: 324403*/
33 #define MAX_PERM_LEN 80 //Fix for svace wgid:324402
35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
36 #define CHECK_OAL_GATT_ENABLED() \
38 if (gatt_api == NULL) { \
39 BT_ERR("GATT Not Enabled"); \
40 return OAL_STATUS_NOT_READY; \
44 #define CHECK_SERVER_INSTANCE(instance_id) \
46 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
47 BT_ERR("Invalid Instance"); \
48 return OAL_STATUS_INVALID_PARAM; \
52 #define CHECK_SERVER_REGISTRATION(instance_id) \
54 if (gatt_servers[instance_id - 1].server_id < 0) {\
55 BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
56 return OAL_STATUS_INTERNAL_ERROR;\
60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
62 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
63 if (gatt_servers[instance_id - 1].server_id == server_if) { \
64 server_inst = instance_id; \
70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
72 char * buf_str = g_malloc0(3*length + 1);\
73 if (NULL != buf_str) { \
74 convert_hex_2_str(manuf_data, length, buf_str);\
75 if (TRUE == data_type) \
76 BT_INFO("Scan Response Data:%s\n", buf_str);\
78 BT_INFO("Advertising Data:%s\n", buf_str);\
83 #define CHECK_CLIENT_REGISTRATION(client_id) \
85 if (client_id <= 0) { \
86 BT_DBG("No client registered yet...");\
87 return OAL_STATUS_INTERNAL_ERROR;\
91 #define CHECK_CLIENT_CONNECTION(conn_id) \
94 BT_ERR("No active connection");\
95 return OAL_STATUS_INTERNAL_ERROR;\
102 GATT_INS_DATA_SETTING,
114 const char *oal_device_type[] = {
125 } oal_pending_gattc_req_e;
127 static const btgatt_interface_t * gatt_api;
128 static gboolean cur_adv_state[NUM_SERVER_INST];
129 static gatt_server_t gatt_servers[NUM_SERVER_INST];
131 /* Forward declarations of GATT Server callbacks */
132 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
133 static void cb_gatts_multi_adv_enable(int server_if, int status);
134 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status);
135 static void cb_gatts_multi_adv_disable(int server_if, int status);
136 static void cb_gatts_multi_adv_update(int server_if, int status);
138 static void cb_gatts_listen(int status, int server_if);
141 static void cb_gatts_service_added(int status, int server_if, btgatt_srvc_id_t *srvc_id, int srvc_handle);
142 static void cb_gatts_included_service_added(int status, int server_if, int srvc_handle, int incl_srvc_handle);
143 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id, int srvc_handle, int char_handle);
144 static void cb_gatts_descriptor_added(int status, int server_if, bt_uuid_t *descr_id, int srvc_handle, int descr_handle);
146 static void cb_gatts_service_started(int status, int server_if, int srvc_handle);
147 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle);
148 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle);
150 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, bool is_long);
151 static void cb_gatts_request_write(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, int length,
152 bool need_rsp, bool is_prep, uint8_t* value);
153 static void cb_gatts_response_confirmation(int status, int handle);
155 static void cb_gatts_acquire_write(int fd, int conn_id, int trans_id, int attr_handle, bt_bdaddr_t*);
156 static void cb_gatts_acquire_notify(int fd, int conn_id, int trans_id, int attr_handle);
158 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
159 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
161 static void cb_gatts_mtu_changed(int conn_id, int mtu);
164 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda);
167 /************************************HAL Interface *************************************/
169 /*TODO GATT Server callbacks will be implemented in subsequent patches */
170 static const btgatt_server_callbacks_t btgatt_server_callbacks = {
171 .register_server_cb = cb_gatts_register_app,
172 .connection_cb = cb_gatts_connection,
173 .service_added_cb = cb_gatts_service_added,
174 .included_service_added_cb = cb_gatts_included_service_added,
175 .characteristic_added_cb = cb_gatts_characteristic_added,
176 .descriptor_added_cb = cb_gatts_descriptor_added,
177 .service_started_cb = cb_gatts_service_started,
178 .service_stopped_cb = cb_gatts_service_stopped,
179 .service_deleted_cb = cb_gatts_service_deleted,
180 .indication_confirmation_cb = cb_indication_confirmation,
181 .request_read_cb = cb_gatts_request_read,
182 .request_write_cb = cb_gatts_request_write,
183 .request_exec_write_cb = NULL,
184 .response_confirmation_cb = cb_gatts_response_confirmation,
185 .listen_cb = cb_gatts_listen,
186 .multi_adv_enable_cb = cb_gatts_multi_adv_enable,
187 .multi_adv_update_cb = cb_gatts_multi_adv_update,
188 .multi_adv_data_cb = cb_gatts_multi_adv_set_inst_data,
189 .multi_adv_disable_cb = cb_gatts_multi_adv_disable,
190 .mtu_changed_cb = cb_gatts_mtu_changed,
192 .notif_enabled_cb = cb_notifcation_changed,
194 .request_acquire_write_cb = cb_gatts_acquire_write,
195 .request_acquire_notify_cb = cb_gatts_acquire_notify
198 /* Forward declaration for GATT client callbacks */
199 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
200 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
201 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
202 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
203 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
204 static void cb_gattc_search_complete(int conn_id, int status);
205 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
206 btgatt_gatt_id_t *char_id, int char_prop);
207 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
208 btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
209 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
210 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
211 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
212 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
213 static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
214 btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
215 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
217 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
218 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
219 .register_client_cb = cb_gattc_register_app,
220 .scan_result_cb = cb_gattc_scan_result,
221 .open_cb = cb_gattc_connection,
222 .close_cb = cb_gattc_disconnect,
223 .search_complete_cb = cb_gattc_search_complete,
224 .search_result_cb = cb_gattc_search_result,
225 .get_characteristic_cb = cb_gattc_get_characteristics,
226 .get_descriptor_cb = cb_gattc_get_descriptor,
227 .get_included_service_cb = NULL,
228 .register_for_notification_cb = cb_gattc_register_for_notification,
229 .notify_cb = cb_gattc_notify,
230 .read_characteristic_cb = cb_gattc_read_characteristic,
231 .write_characteristic_cb = cb_gattc_write_characteristic,
232 .read_descriptor_cb = cb_gattc_read_descriptor,
233 .write_descriptor_cb = cb_gattc_write_descriptor,
234 .execute_write_cb = NULL,
235 .read_remote_rssi_cb = NULL,
236 .configure_mtu_cb = NULL,
237 #ifdef PLATFORM_ANDROID_HAL
238 .scan_filter_cfg_cb = NULL,
239 .scan_filter_param_cb = NULL,
240 .scan_filter_status_cb = NULL,
241 .congestion_cb = NULL,
242 .batchscan_cfg_storage_cb = NULL,
243 .batchscan_enb_disable_cb = NULL,
244 .batchscan_reports_cb = NULL,
245 .batchscan_threshold_cb = NULL,
246 .track_adv_event_cb = NULL,
250 static btgatt_callbacks_t btgatt_callbacks = {
251 sizeof(btgatt_callbacks_t),
252 &btgatt_client_callbacks,
253 &btgatt_server_callbacks
256 /*******************************GATT Initialisation - Deinitialisation********************************/
257 oal_status_t gatt_enable(void)
259 const bt_interface_t * blued_api;
263 for (i = 0; i < NUM_SERVER_INST; i++) {
264 gatt_servers[i].server_id = -1;
265 gatt_servers[i].state = GATT_INS_DISABLED;
266 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
267 cur_adv_state[i] = FALSE;
270 /* Get stack interface */
271 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
273 if (blued_api == NULL) {
274 BT_ERR("Stack is not initialized");
275 return OAL_STATUS_NOT_READY;
279 BT_WARN("GATT Interface is already initialized...");
280 return OAL_STATUS_ALREADY_DONE;
283 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
284 if (gatt_api == NULL) {
285 BT_ERR("GATT interface failed");
286 return OAL_STATUS_INTERNAL_ERROR;
289 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
290 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
293 return convert_to_oal_status(ret);
296 BT_INFO("GATT successfully initialized");
297 return OAL_STATUS_SUCCESS;
300 oal_status_t gatt_disable(void)
308 for (i = 0; i < NUM_SERVER_INST; i++) {
309 gatt_servers[i].server_id = -1;
310 gatt_servers[i].state = GATT_INS_DISABLED;
311 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
313 return OAL_STATUS_SUCCESS;
316 /************************************GATT Server Functions*************************************/
318 oal_status_t gatts_register(oal_uuid_t* server_uuid)
320 char str[2*BT_UUID_STRING_MAX];
321 int ret = OAL_STATUS_SUCCESS;
324 CHECK_OAL_GATT_ENABLED();
325 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
326 API_TRACE("Register the server instance: UUID: [%s]", str);
328 for (i = 0; i < NUM_SERVER_INST; i++) {
329 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
330 if (gatt_servers[i].server_id != -1) {
331 BT_ERR("This is resevered UUID for easy set up application i = %d \
332 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
333 return OAL_STATUS_ALREADY_DONE;
338 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
340 if (ret != BT_STATUS_SUCCESS) {
341 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
342 return convert_to_oal_status(ret);
344 return OAL_STATUS_SUCCESS;
347 oal_status_t gatts_unregister(int instance_id)
349 int ret = OAL_STATUS_SUCCESS;
350 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
352 CHECK_OAL_GATT_ENABLED();
353 CHECK_SERVER_INSTANCE(instance_id);
354 CHECK_SERVER_REGISTRATION(instance_id);
356 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
358 if (ret != BT_STATUS_SUCCESS) {
359 BT_ERR("GATT server unregistration failed: %d", instance_id);
360 return convert_to_oal_status(ret);
363 gatt_servers[instance_id-1].server_id = -1;
364 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
366 if (instance_id != 1 && instance_id != 2)
367 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
369 return OAL_STATUS_SUCCESS;
372 /* Legacy Advertisement */
373 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
375 int ret = OAL_STATUS_SUCCESS;
376 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
378 CHECK_OAL_GATT_ENABLED();
379 CHECK_SERVER_INSTANCE(instance_id);
380 CHECK_SERVER_REGISTRATION(instance_id);
382 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
384 if (ret != BT_STATUS_SUCCESS) {
385 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
386 gatt_servers[instance_id-1].server_id, status2string(ret));
387 return convert_to_oal_status(ret);
390 return OAL_STATUS_SUCCESS;
393 oal_status_t gatts_stop_advertising(int instance_id)
395 int ret = OAL_STATUS_SUCCESS;
396 API_TRACE("Stop advertising");
398 CHECK_OAL_GATT_ENABLED();
399 CHECK_SERVER_INSTANCE(instance_id);
400 CHECK_SERVER_REGISTRATION(instance_id);
402 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
404 if (ret != BT_STATUS_SUCCESS) {
405 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
406 instance_id, status2string(ret));
407 return convert_to_oal_status(ret);
409 return OAL_STATUS_SUCCESS;
413 /* Below API's need to be removed as they are hardcoded API's.
414 If at all, product specific API's are required to set specific data, then new naming should
415 be adopted for these API's */
416 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
418 int ret = OAL_STATUS_SUCCESS;
420 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
421 CHECK_OAL_GATT_ENABLED();
422 CHECK_SERVER_INSTANCE(instance_id);
423 CHECK_SERVER_REGISTRATION(instance_id);
425 /* Historically used for Legacy Advertising */
426 return OAL_STATUS_NOT_SUPPORT;
429 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
431 int ret = OAL_STATUS_SUCCESS;
433 API_TRACE("Set advertising data");
434 CHECK_OAL_GATT_ENABLED();
435 CHECK_SERVER_INSTANCE(instance_id);
436 CHECK_SERVER_REGISTRATION(instance_id);
438 /* Historically used for Legacy Advertising */
439 return OAL_STATUS_NOT_SUPPORT;
442 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
444 int ret = OAL_STATUS_SUCCESS;
446 API_TRACE("Set Scan Response data");
447 CHECK_OAL_GATT_ENABLED();
448 CHECK_SERVER_INSTANCE(instance_id);
449 CHECK_SERVER_REGISTRATION(instance_id);
451 /* Historically used for Legacy Advertising */
452 return OAL_STATUS_NOT_SUPPORT;
456 oal_status_t gatts_multi_adv_enable(int instance_id)
458 int ret = OAL_STATUS_SUCCESS;
459 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
460 gatt_servers[instance_id - 1].server_id, instance_id);
462 CHECK_OAL_GATT_ENABLED();
463 CHECK_SERVER_INSTANCE(instance_id);
464 CHECK_SERVER_REGISTRATION(instance_id);
466 if (gatt_api->server->multi_adv_enable == NULL)
467 return OAL_STATUS_NOT_SUPPORT;
469 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
470 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
471 BT_ERR("Not allowed, state: %d, instance_id: %d",
472 gatt_servers[instance_id - 1].state, instance_id);
473 return OAL_STATUS_BUSY;
476 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
477 BT_ERR("Not allowed, state: %d, instance_id: %d",
478 gatt_servers[instance_id - 1].state, instance_id);
479 return OAL_STATUS_ALREADY_DONE;
482 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
483 BT_ERR("Not allowed, state: %d, instance_id: %d",
484 gatt_servers[instance_id - 1].state, instance_id);
485 return OAL_STATUS_BUSY;
488 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
490 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
492 if (ret != BT_STATUS_SUCCESS) {
493 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
494 instance_id, status2string(ret));
495 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
496 return convert_to_oal_status(ret);
498 return OAL_STATUS_SUCCESS;
501 oal_status_t gatts_multi_adv_disable(int instance_id)
503 int ret = OAL_STATUS_SUCCESS;
504 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
505 gatt_servers[instance_id - 1].server_id, instance_id);
507 CHECK_OAL_GATT_ENABLED();
508 CHECK_SERVER_INSTANCE(instance_id);
509 CHECK_SERVER_REGISTRATION(instance_id);
511 if (gatt_api->server->multi_adv_disable == NULL)
512 return OAL_STATUS_NOT_SUPPORT;
514 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
515 BT_ERR("Not Allowed, state: %d, instance_id: %d",
516 gatt_servers[instance_id - 1].state, instance_id);
517 return OAL_STATUS_BUSY;
520 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
522 if (ret != BT_STATUS_SUCCESS) {
523 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
524 instance_id, status2string(ret));
525 return convert_to_oal_status(ret);
527 return OAL_STATUS_SUCCESS;
530 oal_status_t gatts_multi_adv_update(int instance_id,
531 int min_intv, int max_intv,
532 int adv_type, int chnl_map,
533 int tx_power, int timeout_s)
535 int ret = OAL_STATUS_SUCCESS;
536 API_TRACE("Multi advertising Update");
538 CHECK_OAL_GATT_ENABLED();
539 CHECK_SERVER_INSTANCE(instance_id);
540 CHECK_SERVER_REGISTRATION(instance_id);
542 if (gatt_api->server->multi_adv_update == NULL)
543 return OAL_STATUS_NOT_SUPPORT;
545 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
548 tx_power, timeout_s);
550 if (ret != BT_STATUS_SUCCESS) {
551 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
552 instance_id, status2string(ret));
553 return convert_to_oal_status(ret);
555 return OAL_STATUS_SUCCESS;
558 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
559 oal_ble_multi_adv_param_setup_t *adv_param_setup)
561 int ret = OAL_STATUS_SUCCESS;
562 btgatt_adv_param_setup_t adv_setup;
563 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
564 gatt_servers[instance_id - 1].server_id, instance_id);
566 CHECK_OAL_GATT_ENABLED();
567 CHECK_SERVER_INSTANCE(instance_id);
568 CHECK_SERVER_REGISTRATION(instance_id);
570 if (gatt_api->server->multi_adv_set_inst_data == NULL)
571 return OAL_STATUS_NOT_SUPPORT;
573 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
574 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
575 return OAL_STATUS_BUSY;
578 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
581 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
582 adv_setup.include_name = adv_param_setup->include_name;
583 adv_setup.include_txpower = adv_param_setup->include_txpower;
584 adv_setup.appearance = adv_param_setup->appearance;
585 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
586 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
587 adv_setup.service_data = adv_param_setup->service_data;
588 adv_setup.service_data_len = adv_param_setup->service_data_len;
589 adv_setup.service_uuid = adv_param_setup->service_uuid;
590 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
591 /* Solicit UUID handler: Start */
592 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
593 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
594 /* Solicit UUID handler: End */
595 adv_setup.min_interval = adv_param_setup->min_interval;
596 adv_setup.max_interval = adv_param_setup->min_interval;
597 adv_setup.adv_type = adv_param_setup->adv_type;
598 adv_setup.chnl_map = adv_param_setup->chnl_map;
599 adv_setup.tx_power = adv_param_setup->tx_power;
600 adv_setup.timeout_s = adv_param_setup->timeout_s;
602 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
603 if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
604 BT_INFO("Manufacture data.....\n");
605 PRINT_ADV_DATA(adv_setup.manufacturer_data_len, (unsigned char *)adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
608 if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
609 BT_INFO("Service uuid.....\n");
610 PRINT_ADV_DATA(adv_setup.service_uuid_len, (unsigned char*)adv_setup.service_uuid, FALSE);
614 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
616 if (ret != BT_STATUS_SUCCESS) {
617 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
618 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
619 return convert_to_oal_status(ret);
621 return OAL_STATUS_SUCCESS;
624 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
626 int ret = OAL_STATUS_SUCCESS;
629 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
631 CHECK_OAL_GATT_ENABLED();
632 CHECK_SERVER_INSTANCE(instance_id);
633 CHECK_SERVER_REGISTRATION(instance_id);
635 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
637 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
638 if (ret != BT_STATUS_SUCCESS) {
639 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
640 return convert_to_oal_status(ret);
642 return OAL_STATUS_SUCCESS;
646 /************************************GATT Server Functions*************************************/
648 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
651 char str[2*BT_UUID_STRING_MAX];
652 uuid_to_stringname((service_uuid_t*)uuid, str);
654 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
656 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
657 BT_INFO("UUID: [%s]", str);
659 for (i = 0; i < NUM_SERVER_INST; i++) {
660 if (gatt_servers[i].server_id == -1) {
661 BT_INFO("Server Instance registered with stack [%d]", i+1);
662 gatt_servers[i].server_id = server_if;
663 event->server_inst = i+1;
664 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
665 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
669 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
672 static void cb_gatts_listen(int status, int server_if)
674 gboolean prev_state[NUM_SERVER_INST];
676 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
679 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
680 if (gatt_servers[instance_id - 1].server_id == server_if) {
681 event->server_inst = instance_id;
684 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
687 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
688 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
689 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
690 cur_adv_state[event->server_inst - 1] = new_state;
692 BT_ERR("Invalid Callback...");
697 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
699 if (TRUE == new_state)
700 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
702 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
705 static void cb_gatts_multi_adv_enable(int server_if, int status)
708 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
709 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
712 if (status != BT_STATUS_SUCCESS)
713 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
715 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
716 if (gatt_servers[instance_id - 1].server_id == server_if) {
717 event->server_inst = instance_id;
718 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
722 BT_ERR("Invalid Interface, srv_if: %d", server_if);
723 event->server_inst = -1;
725 event->status = convert_to_oal_status(status);
726 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
729 static void cb_gatts_multi_adv_disable(int server_if, int status)
731 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
732 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
735 if (status != BT_STATUS_SUCCESS)
736 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
738 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
739 if (gatt_servers[instance_id - 1].server_id == server_if) {
740 event->server_inst = instance_id;
741 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
745 BT_ERR("Invalid Interface, srv_if: %d", server_if);
746 event->server_inst = -1;
748 event->status = convert_to_oal_status(status);
749 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
752 static void cb_gatts_multi_adv_update(int server_if, int status)
754 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
755 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
758 if (status != BT_STATUS_SUCCESS)
759 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
761 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
762 if (gatt_servers[instance_id - 1].server_id == server_if) {
763 event->server_inst = instance_id;
767 BT_ERR("Invalid Interface, srv_if: %d", server_if);
768 event->server_inst = -1;
770 event->status = convert_to_oal_status(status);
771 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
774 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
776 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
777 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
780 if (status != BT_STATUS_SUCCESS)
781 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
783 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
784 if (gatt_servers[instance_id - 1].server_id == server_if) {
785 event->server_inst = instance_id;
786 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
790 BT_ERR("Invalid Interface, srv_if: %d", server_if);
791 event->server_inst = -1;
793 event->status = convert_to_oal_status(status);
794 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
797 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
799 int ret = OAL_STATUS_SUCCESS;
800 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
801 CHECK_OAL_GATT_ENABLED();
802 OAL_CHECK_PARAMETER(mtu, return);
804 /* To prevent crash in case other libraries not support this api */
805 if (gatt_api->server->get_att_mtu == NULL) {
806 BT_WARN("get_att_mtu is NULL");
807 return OAL_STATUS_NOT_SUPPORT;
810 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
811 if (ret != BT_STATUS_SUCCESS) {
812 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
813 return convert_to_oal_status(ret);
816 BT_INFO("Current ATT MTU Size: %d", *mtu);
817 return OAL_STATUS_SUCCESS;
819 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
820 int status, int fd, int mtu , void * fdlist)
822 int ret = OAL_STATUS_SUCCESS;
824 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
825 CHECK_OAL_GATT_ENABLED();
827 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
828 if (ret != BT_STATUS_SUCCESS) {
829 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
830 return convert_to_oal_status(ret);
832 return OAL_STATUS_SUCCESS;
835 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
838 int ret = OAL_STATUS_SUCCESS;
839 btgatt_srvc_id_t btgatt_srvc_id;
840 char str[2*BT_UUID_STRING_MAX];
842 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
843 CHECK_OAL_GATT_ENABLED();
845 CHECK_SERVER_INSTANCE(instance_id);
846 CHECK_SERVER_REGISTRATION(instance_id);
848 if (gatt_serv_id != NULL) {
849 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
850 API_TRACE("Service uuid: [%s]", str);
851 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
852 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
853 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
855 BT_INFO("GATT Server Service Id is NULL");
856 return OAL_STATUS_INVALID_PARAM;
859 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
861 if (ret != BT_STATUS_SUCCESS) {
862 BT_ERR("GATT Server add service failed: %s", status2string(ret));
863 return convert_to_oal_status(ret);
865 return OAL_STATUS_SUCCESS;
868 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
871 int ret = OAL_STATUS_SUCCESS;
872 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
873 instance_id, serv_handle, incl_handle);
874 CHECK_OAL_GATT_ENABLED();
876 CHECK_SERVER_INSTANCE(instance_id);
878 CHECK_SERVER_REGISTRATION(instance_id);
880 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
881 if (ret != BT_STATUS_SUCCESS) {
882 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
883 return convert_to_oal_status(ret);
885 return OAL_STATUS_SUCCESS;
888 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
889 oal_uuid_t* charc_uuid, int propts, int permsn)
891 int ret = OAL_STATUS_SUCCESS;
892 char str[2*BT_UUID_STRING_MAX];
893 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
894 char_prop_to_string(propts, prop);
895 char_perm_to_string(permsn, perm);
896 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
897 instance_id, serv_handle, prop, perm);
898 CHECK_OAL_GATT_ENABLED();
900 CHECK_SERVER_INSTANCE(instance_id);
902 CHECK_SERVER_REGISTRATION(instance_id);
904 if (charc_uuid != NULL) {
905 uuid_to_stringname(charc_uuid, str);
906 API_TRACE("uuid: [%s]", str);
909 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
910 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
911 if (ret != BT_STATUS_SUCCESS) {
912 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
913 return convert_to_oal_status(ret);
915 return OAL_STATUS_SUCCESS;
918 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
919 oal_uuid_t* desc_uuid, int permsn)
921 int ret = OAL_STATUS_SUCCESS;
922 char str[2*BT_UUID_STRING_MAX];
923 char perm[MAX_PERM_LEN];
924 char_perm_to_string(permsn, perm);
925 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
926 instance_id, serv_handle, perm);
927 CHECK_OAL_GATT_ENABLED();
929 CHECK_SERVER_INSTANCE(instance_id);
931 CHECK_SERVER_REGISTRATION(instance_id);
933 if (desc_uuid != NULL) {
934 uuid_to_stringname(desc_uuid, str);
935 API_TRACE("uuid: [%s]", str);
938 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
939 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
941 if (ret != BT_STATUS_SUCCESS) {
942 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
943 return convert_to_oal_status(ret);
945 return OAL_STATUS_SUCCESS;
948 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
950 int ret = OAL_STATUS_SUCCESS;
952 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
953 instance_id, svc_handle, transport);
954 CHECK_OAL_GATT_ENABLED();
956 CHECK_SERVER_INSTANCE(instance_id);
958 CHECK_SERVER_REGISTRATION(instance_id);
960 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
962 if (ret != BT_STATUS_SUCCESS) {
963 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
964 return convert_to_oal_status(ret);
966 return OAL_STATUS_SUCCESS;
969 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
971 int ret = OAL_STATUS_SUCCESS;
973 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
974 CHECK_OAL_GATT_ENABLED();
976 CHECK_SERVER_INSTANCE(ins_id);
977 CHECK_SERVER_REGISTRATION(ins_id);
979 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
980 if (ret != BT_STATUS_SUCCESS) {
981 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
982 return convert_to_oal_status(ret);
984 return OAL_STATUS_SUCCESS;
987 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
989 int ret = OAL_STATUS_SUCCESS;
991 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
992 CHECK_OAL_GATT_ENABLED();
994 CHECK_SERVER_INSTANCE(ins_id);
996 CHECK_SERVER_REGISTRATION(ins_id);
998 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
999 if (ret != BT_STATUS_SUCCESS) {
1000 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1001 return convert_to_oal_status(ret);
1003 return OAL_STATUS_SUCCESS;
1006 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1008 int ret = OAL_STATUS_SUCCESS;
1010 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1011 CHECK_OAL_GATT_ENABLED();
1013 if (response == NULL) {
1014 BT_ERR("GATT Server attribute value is empty");
1015 return OAL_STATUS_INVALID_PARAM;
1018 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1019 if (ret != BT_STATUS_SUCCESS) {
1020 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1021 return convert_to_oal_status(ret);
1023 return OAL_STATUS_SUCCESS;
1026 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1028 int ret = OAL_STATUS_SUCCESS;
1030 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1031 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1032 CHECK_OAL_GATT_ENABLED();
1034 CHECK_SERVER_INSTANCE(ins_id);
1036 CHECK_SERVER_REGISTRATION(ins_id);
1038 if (value == NULL || len == 0) {
1039 BT_ERR("GATT Server attribute value is empty");
1040 return OAL_STATUS_INVALID_PARAM;
1043 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1044 attr_hndl, conn_id, len, confirm, value);
1046 if (ret != BT_STATUS_SUCCESS) {
1047 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1048 return convert_to_oal_status(ret);
1050 return OAL_STATUS_SUCCESS;
1053 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1055 int ret = OAL_STATUS_SUCCESS;
1057 CHECK_OAL_GATT_ENABLED();
1059 CHECK_SERVER_INSTANCE(ins_id);
1061 CHECK_SERVER_REGISTRATION(ins_id);
1063 if (value == NULL || value->len == 0) {
1064 BT_ERR("GATT Server attribute value is empty");
1065 return OAL_STATUS_INVALID_PARAM;
1068 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1069 ins_id, value->handle, value->len);
1071 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1072 (int)value->handle, (int)value->len, (char*)value->value);
1074 if (ret != BT_STATUS_SUCCESS) {
1075 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1076 return convert_to_oal_status(ret);
1078 return OAL_STATUS_SUCCESS;
1081 /* GATT Server Callbacks:Start */
1082 static void cb_gatts_service_added(int status, int server_if,
1083 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1087 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1088 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1090 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1092 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1093 event->gatt_srvc_stat.server_inst = -1;
1095 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1096 if (psrvc_id != NULL) {
1097 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1098 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1099 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1100 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1103 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1105 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1108 static void cb_gatts_included_service_added(int status, int server_if,
1110 int incl_srvc_handle)
1113 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1114 status, srvc_handle, incl_srvc_handle);
1116 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1118 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1120 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1121 event->gatt_srvc_stat.server_inst = -1;
1123 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1124 event->incl_srvc_hndl = incl_srvc_handle;
1125 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1126 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1129 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1130 int srvc_handle, int char_handle)
1134 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1135 status, srvc_handle, char_handle);
1137 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1139 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1141 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1142 event->gatt_srvc_stat.server_inst = -1;
1144 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1145 event->charctr_hndl = char_handle;
1146 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1147 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1148 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1151 static void cb_gatts_descriptor_added(int status, int server_if,
1152 bt_uuid_t *descr_id, int srvc_handle,
1156 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1157 status, srvc_handle, descr_handle);
1159 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1161 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1163 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1164 event->gatt_srvc_stat.server_inst = -1;
1166 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1167 event->descrptr_hndl = descr_handle;
1168 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1169 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1170 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1173 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1176 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1178 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1180 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1182 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1183 event->server_inst = -1;
1185 event->servic_hndl = srvc_handle;
1186 event->status = convert_to_oal_status(status);
1187 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1190 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1193 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1195 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1197 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1199 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1200 event->server_inst = -1;
1202 event->servic_hndl = srvc_handle;
1203 event->status = convert_to_oal_status(status);
1204 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1207 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1210 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1212 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1214 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1216 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1217 event->server_inst = -1;
1219 event->servic_hndl = srvc_handle;
1220 event->status = convert_to_oal_status(status);
1221 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1224 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1227 oal_event_t event_type;
1229 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1230 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1232 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1233 if ((gatt_servers[ins_id - 1].server_id == server_if) &&
1234 (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
1235 event->server_inst = ins_id;
1238 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1241 if (ins_id == NUM_SERVER_INST+1) {
1242 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1246 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1247 event->conn_id = conn_id;
1248 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1249 event->status = OAL_STATUS_SUCCESS;
1251 send_event(event_type, event, sizeof(event_gatts_conn_t));
1254 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1255 int attr_handle, int offset, bool is_long)
1257 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1259 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1261 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1263 event->attr_trans.attr_handle = attr_handle;
1264 event->attr_trans.conn_id = conn_id;
1265 event->attr_trans.trans_id = trans_id;
1266 event->attr_trans.offset = offset;
1267 event->is_long = is_long;
1269 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1272 static void cb_gatts_request_write(int conn_id, int trans_id,
1273 bt_bdaddr_t *bda, int attr_handle,
1274 int offset, int length,
1275 bool need_rsp, bool is_prep, uint8_t* value)
1277 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1279 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1281 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1283 event->attr_trans.attr_handle = attr_handle;
1284 event->attr_trans.conn_id = conn_id;
1285 event->attr_trans.trans_id = trans_id;
1286 event->attr_trans.offset = offset;
1287 event->need_rsp = need_rsp;
1288 event->is_prep = is_prep;
1290 if (length > 0 && value != NULL) {
1291 if (length > OAL_GATT_MAX_ATTR_LEN)
1292 length = OAL_GATT_MAX_ATTR_LEN;
1293 memcpy(event->value, value, length);
1294 event->length = length;
1296 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1299 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1302 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1304 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1306 event->attr_trans.attr_handle = attr_handle;
1307 event->attr_trans.conn_id = conn_id;
1308 event->attr_trans.trans_id = trans_id;
1310 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1312 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1315 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1317 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1319 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1321 event->attr_trans.attr_handle = attr_handle;
1322 event->attr_trans.conn_id = conn_id;
1323 event->attr_trans.trans_id = trans_id;
1326 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1330 static void cb_gatts_response_confirmation(int status, int handle)
1332 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1334 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1336 event->hndl = handle;
1337 event->status = convert_to_oal_status(status);
1339 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1342 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1344 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1345 conn_id, trans_id, attr_handle);
1347 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1349 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1351 event->attr_handle = attr_handle;
1352 event->conn_id = conn_id;
1353 event->trans_id = trans_id;
1354 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1357 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1359 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1360 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1361 event->conn_id = conn_id;
1362 event->mtu_size = mtu;
1363 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1367 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1369 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1370 conn_id, trans_id, attr_handle, notify);
1372 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1374 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1376 event->attr_handle = attr_handle;
1377 event->conn_id = conn_id;
1378 event->trans_id = trans_id;
1379 event->notify = notify;
1380 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1385 /* GATT Server Callbacks: End */
1386 /************************************ GATT Client ***********************************/
1387 /* Client Callbacks */
1388 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1390 char uuid_str[BT_UUID_STRING_MAX];
1391 event_gattc_register_t *event;
1395 /* Check if GATT client registered for Default GATT client UUID */
1396 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1397 BT_INFO("UUID:%s", uuid_str);
1399 BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1400 event = g_new0(event_gattc_register_t, 1);
1401 event->client_if = clientIf;
1402 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1403 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1404 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1407 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1409 event_ble_scan_result_info *event;
1411 event = g_new0(event_ble_scan_result_info, 1);
1413 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1414 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1415 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1416 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1419 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1421 event_gattc_conn_t *event;
1422 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1423 status, client_if, conn_id);
1425 event = g_new0(event_gattc_conn_t, 1);
1426 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1427 event->client_if = client_if;
1429 if (BT_STATUS_SUCCESS != status) {
1430 event->status = OAL_STATUS_INTERNAL_ERROR;
1431 BT_ERR("gattc connection Error: %d", status);
1433 event->conn_id = conn_id;
1434 event->status = OAL_STATUS_SUCCESS;
1437 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1438 sizeof(*event), (bt_address_t *)bda);
1442 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1444 event_gattc_conn_t *event;
1445 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1446 status, client_if, conn_id);
1447 event = g_new0(event_gattc_conn_t, 1);
1448 event->status = convert_to_oal_status(status);
1449 event->client_if = client_if;
1450 event->conn_id = conn_id;
1451 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1452 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1453 sizeof(*event), (bt_address_t *)bda);
1456 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1458 char uuid_str[2*BT_UUID_STRING_MAX];
1460 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1462 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1463 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1464 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1466 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1467 event->conn_status.status = OAL_STATUS_SUCCESS;
1468 event->conn_status.conn_id = conn_id;
1469 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1471 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1474 static void cb_gattc_search_complete(int conn_id, int status)
1476 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1479 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1480 event->conn_id = conn_id;
1481 event->status = convert_to_oal_status(status);
1483 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1487 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1488 btgatt_gatt_id_t *char_id, int char_prop)
1490 char uuid_str1[2*BT_UUID_STRING_MAX];
1491 char uuid_str2[2*BT_UUID_STRING_MAX];
1493 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1494 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1495 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1496 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1498 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1499 event->conn_status.conn_id = conn_id;
1500 event->conn_status.status = convert_to_oal_status(status);
1501 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1504 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1505 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u], Prop: [%s]",
1506 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1507 event->char_prop = char_prop;
1508 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1510 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1515 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id)
1517 char uuid_str1[2*BT_UUID_STRING_MAX];
1518 char uuid_str2[2*BT_UUID_STRING_MAX];
1519 char uuid_str3[2*BT_UUID_STRING_MAX];
1520 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1521 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1522 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1523 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1524 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1525 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1527 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1528 event->conn_status.conn_id = conn_id;
1529 event->conn_status.status = convert_to_oal_status(status);
1530 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1531 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1534 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1535 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, descr_id->inst_id);
1536 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1538 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1541 static void cb_gattc_register_for_notification(int client_if, int registered, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id)
1543 char uuid_str1[2*BT_UUID_STRING_MAX];
1544 char uuid_str2[2*BT_UUID_STRING_MAX];
1545 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1546 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1547 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1548 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1549 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1550 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1552 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1553 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1554 event->client_if = client_if;
1555 event->status = convert_to_oal_status(status);
1556 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1557 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1559 send_event(event_type, event, sizeof(*event));
1562 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1565 char uuid_str1[2*BT_UUID_STRING_MAX];
1566 char uuid_str2[2*BT_UUID_STRING_MAX];
1568 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1569 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1570 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1572 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1573 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1575 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1576 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1577 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1579 if (p_data->len > 0) {
1581 data = g_malloc(3*p_data->len+1);
1583 BT_ERR("memory allocation failed");
1587 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1588 BT_INFO("Notified Data: [%s]", data);
1590 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1591 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1592 event->is_notify = p_data->is_notify;
1593 event->data_len = p_data->len;
1594 memcpy(event->data, p_data->value, event->data_len);
1595 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1596 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1598 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1604 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1606 char uuid_str1[2*BT_UUID_STRING_MAX];
1607 char uuid_str2[2*BT_UUID_STRING_MAX];
1608 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1610 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1611 event->uuid_status.conn_status.conn_id = conn_id;
1612 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1613 event->value_type = p_data->value_type;
1614 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1615 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1617 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1618 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1619 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1620 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1621 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1622 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1623 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1625 data = g_malloc(3*p_data->value.len+1);
1627 BT_ERR("memory allocation failed");
1631 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1632 BT_INFO("Read Data: [%s]", data);
1633 event->data_len = p_data->value.len;
1634 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1638 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1641 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1643 char uuid_str1[2*BT_UUID_STRING_MAX];
1644 char uuid_str2[2*BT_UUID_STRING_MAX];
1645 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1647 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1648 event->conn_status.conn_id = conn_id;
1649 event->conn_status.status = convert_to_oal_status(status);
1650 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1651 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1653 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1654 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1655 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1656 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1657 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1659 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1662 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1664 char uuid_str1[2*BT_UUID_STRING_MAX];
1665 char uuid_str2[2*BT_UUID_STRING_MAX];
1666 char uuid_str3[2*BT_UUID_STRING_MAX];
1667 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1669 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1670 event->conn_status.conn_id = conn_id;
1671 event->conn_status.status = convert_to_oal_status(status);
1672 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1673 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1674 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1676 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1677 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1678 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1679 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1680 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1681 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1682 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1684 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1689 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1691 char uuid_str1[2*BT_UUID_STRING_MAX];
1692 char uuid_str2[2*BT_UUID_STRING_MAX];
1693 char uuid_str3[2*BT_UUID_STRING_MAX];
1694 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1696 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1697 event->uuid_status.conn_status.conn_id = conn_id;
1698 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1699 event->value_type = p_data->value_type;
1700 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1701 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1702 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1705 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1706 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1707 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1708 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1709 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1710 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1711 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1712 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1713 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1715 data = g_malloc(3*p_data->value.len+1);
1717 BT_ERR("memory allocation failed");
1721 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1722 BT_INFO("Read Data: [%s]", data);
1723 event->data_len = p_data->value.len;
1724 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1728 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1731 oal_status_t gattc_start_le_discovery(int client_id)
1734 int ret = OAL_STATUS_SUCCESS;
1736 API_TRACE("BTGATT CLIENT SCAN START");
1737 CHECK_OAL_GATT_ENABLED();
1738 CHECK_CLIENT_REGISTRATION(client_id);
1740 ret = gatt_api->client->scan(client_id, 1);
1741 if (ret != BT_STATUS_SUCCESS) {
1742 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1743 return convert_to_oal_status(ret);
1745 send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1746 return OAL_STATUS_SUCCESS;
1749 oal_status_t gattc_stop_le_discovery(int client_id)
1752 int ret = OAL_STATUS_SUCCESS;
1754 API_TRACE("Scan is stopped");
1755 CHECK_OAL_GATT_ENABLED();
1756 CHECK_CLIENT_REGISTRATION(client_id);
1757 ret = gatt_api->client->scan(client_id, 0);
1758 if (ret != BT_STATUS_SUCCESS) {
1759 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1760 return convert_to_oal_status(ret);
1762 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1763 return OAL_STATUS_SUCCESS;
1766 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1770 API_TRACE("Scan is stopped");
1771 CHECK_OAL_GATT_ENABLED();
1774 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1775 if (ret != BT_STATUS_SUCCESS) {
1776 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1777 return convert_to_oal_status(ret);
1780 ret = gatt_api->client->set_scan_parameters(itv, win);
1781 if (ret != BT_STATUS_SUCCESS) {
1782 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1783 return convert_to_oal_status(ret);
1787 return OAL_STATUS_SUCCESS;
1789 /************************************ GATT Client ***********************************/
1790 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1793 char str[2*BT_UUID_STRING_MAX];
1794 int ret = OAL_STATUS_SUCCESS;
1796 CHECK_OAL_GATT_ENABLED();
1797 uuid_to_stringname(client_uuid, str);
1798 API_TRACE("uuid: [%s]", str);
1799 /* We will perform actual registration in cb_gattc_register_app callback */
1800 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1801 if (ret != BT_STATUS_SUCCESS) {
1802 BT_ERR("GATT client register failed: %s", status2string(ret));
1803 return convert_to_oal_status(ret);
1805 return OAL_STATUS_SUCCESS;
1808 oal_status_t gattc_deregister(int client_id)
1810 int ret = OAL_STATUS_SUCCESS;
1812 API_TRACE("GATT client deregister");
1813 CHECK_OAL_GATT_ENABLED();
1814 CHECK_CLIENT_REGISTRATION(client_id);
1816 ret = gatt_api->client->unregister_client(client_id);
1817 if (ret != BT_STATUS_SUCCESS) {
1818 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1819 return convert_to_oal_status(ret);
1822 return OAL_STATUS_SUCCESS;
1825 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1827 int ret = OAL_STATUS_SUCCESS;
1830 OAL_CHECK_PARAMETER(device_address, return);
1831 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1832 CHECK_OAL_GATT_ENABLED();
1833 CHECK_CLIENT_REGISTRATION(client_id);
1835 /* Handle the actual connection in cb_gattc_connection callback */
1836 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1837 if (ret != BT_STATUS_SUCCESS) {
1838 BT_ERR("GATT client connect failed: %s", status2string(ret));
1839 return convert_to_oal_status(ret);
1841 return OAL_STATUS_SUCCESS;
1844 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1847 int ret = OAL_STATUS_SUCCESS;
1850 OAL_CHECK_PARAMETER(device_address, return);
1851 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1852 CHECK_OAL_GATT_ENABLED();
1853 CHECK_CLIENT_REGISTRATION(client_id);
1854 CHECK_CLIENT_CONNECTION(conn_id);
1856 /* Handle actual disconnection in callback */
1857 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1858 if (ret != BT_STATUS_SUCCESS) {
1859 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1860 return convert_to_oal_status(ret);
1862 return OAL_STATUS_SUCCESS;
1866 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1868 int ret = OAL_STATUS_SUCCESS;
1869 char uuid_str[2*BT_UUID_STRING_MAX];
1872 uuid_to_stringname(service_uuid, uuid_str);
1873 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1875 API_TRACE("Client Service Search All");
1877 CHECK_OAL_GATT_ENABLED();
1878 CHECK_CLIENT_CONNECTION(conn_id);
1879 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1881 if (ret != BT_STATUS_SUCCESS) {
1882 BT_ERR("GATT client service search failed: %s", status2string(ret));
1883 return convert_to_oal_status(ret);
1885 return OAL_STATUS_SUCCESS;
1888 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1890 int ret = OAL_STATUS_SUCCESS;
1891 char uuid_str[2*BT_UUID_STRING_MAX];
1893 OAL_CHECK_PARAMETER(srvc_id, return);
1894 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1895 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1896 CHECK_OAL_GATT_ENABLED();
1897 CHECK_CLIENT_CONNECTION(conn_id);
1898 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1899 (btgatt_gatt_id_t *)char_id);
1900 if (ret != BT_STATUS_SUCCESS) {
1901 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1902 return convert_to_oal_status(ret);
1904 return OAL_STATUS_SUCCESS;
1907 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1908 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1910 int ret = OAL_STATUS_SUCCESS;
1911 char uuid_str1[2*BT_UUID_STRING_MAX];
1912 char uuid_str2[2*BT_UUID_STRING_MAX];
1914 OAL_CHECK_PARAMETER(srvc_id, return);
1915 OAL_CHECK_PARAMETER(char_id, return);
1916 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1917 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1918 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1919 CHECK_OAL_GATT_ENABLED();
1920 CHECK_CLIENT_CONNECTION(conn_id);
1921 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1922 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1923 if (ret != BT_STATUS_SUCCESS) {
1924 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1925 return convert_to_oal_status(ret);
1927 return OAL_STATUS_SUCCESS;
1930 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1931 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1932 int ret = OAL_STATUS_SUCCESS;
1933 char uuid_str1[2*BT_UUID_STRING_MAX];
1934 char uuid_str2[2*BT_UUID_STRING_MAX];
1937 OAL_CHECK_PARAMETER(address, return);
1938 OAL_CHECK_PARAMETER(srvc_id, return);
1939 OAL_CHECK_PARAMETER(char_id, return);
1940 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1941 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1942 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1943 CHECK_OAL_GATT_ENABLED();
1944 CHECK_CLIENT_REGISTRATION(client_id);
1946 ret = gatt_api->client->register_for_notification(client_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
1947 if (ret != BT_STATUS_SUCCESS) {
1948 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1949 return convert_to_oal_status(ret);
1952 return OAL_STATUS_SUCCESS;
1955 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1956 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1957 int ret = OAL_STATUS_SUCCESS;
1958 char uuid_str1[2*BT_UUID_STRING_MAX];
1959 char uuid_str2[2*BT_UUID_STRING_MAX];
1962 OAL_CHECK_PARAMETER(address, return);
1963 OAL_CHECK_PARAMETER(srvc_id, return);
1964 OAL_CHECK_PARAMETER(char_id, return);
1965 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1966 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1967 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1968 CHECK_OAL_GATT_ENABLED();
1969 CHECK_CLIENT_REGISTRATION(client_id);
1971 ret = gatt_api->client->deregister_for_notification(client_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
1972 if (ret != BT_STATUS_SUCCESS) {
1973 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
1974 return convert_to_oal_status(ret);
1977 return OAL_STATUS_SUCCESS;
1981 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1982 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
1984 int ret = OAL_STATUS_SUCCESS;
1985 char uuid_str1[2*BT_UUID_STRING_MAX];
1986 char uuid_str2[2*BT_UUID_STRING_MAX];
1988 OAL_CHECK_PARAMETER(srvc_id, return);
1989 OAL_CHECK_PARAMETER(char_id, return);
1990 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1991 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1992 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1993 CHECK_OAL_GATT_ENABLED();
1994 CHECK_CLIENT_CONNECTION(conn_id);
1996 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1997 (btgatt_gatt_id_t *)char_id, auth_req);
1998 if (ret != BT_STATUS_SUCCESS) {
1999 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2000 return convert_to_oal_status(ret);
2003 return OAL_STATUS_SUCCESS;
2006 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2007 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2009 int ret = OAL_STATUS_SUCCESS;
2010 char uuid_str1[2*BT_UUID_STRING_MAX];
2011 char uuid_str2[2*BT_UUID_STRING_MAX];
2012 char uuid_str3[2*BT_UUID_STRING_MAX];
2014 OAL_CHECK_PARAMETER(srvc_id, return);
2015 OAL_CHECK_PARAMETER(char_id, return);
2016 OAL_CHECK_PARAMETER(desc_id, return);
2017 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2018 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2019 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2020 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2021 uuid_str1, uuid_str2, uuid_str3);
2022 CHECK_OAL_GATT_ENABLED();
2023 CHECK_CLIENT_CONNECTION(conn_id);
2025 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2026 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2027 if (ret != BT_STATUS_SUCCESS) {
2028 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2029 return convert_to_oal_status(ret);
2032 return OAL_STATUS_SUCCESS;
2035 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2036 oal_gatt_id_t *char_id, int *fd, int *mtu)
2038 int ret = OAL_STATUS_SUCCESS;
2039 char uuid_str1[2*BT_UUID_STRING_MAX];
2040 char uuid_str2[2*BT_UUID_STRING_MAX];
2041 OAL_CHECK_PARAMETER(srvc_id, return);
2042 OAL_CHECK_PARAMETER(char_id, return);
2043 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2044 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2045 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2046 CHECK_OAL_GATT_ENABLED();
2047 CHECK_CLIENT_CONNECTION(conn_id);
2049 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2050 (btgatt_gatt_id_t *)char_id, fd, mtu);
2051 if (ret != BT_STATUS_SUCCESS) {
2052 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2053 return convert_to_oal_status(ret);
2056 return OAL_STATUS_SUCCESS;
2059 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2060 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2062 int ret = OAL_STATUS_SUCCESS;
2063 char uuid_str1[2*BT_UUID_STRING_MAX];
2064 char uuid_str2[2*BT_UUID_STRING_MAX];
2065 OAL_CHECK_PARAMETER(srvc_id, return);
2066 OAL_CHECK_PARAMETER(char_id, return);
2067 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2068 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2069 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2070 CHECK_OAL_GATT_ENABLED();
2071 CHECK_CLIENT_CONNECTION(conn_id);
2073 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2074 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2075 if (ret != BT_STATUS_SUCCESS) {
2076 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2077 return convert_to_oal_status(ret);
2080 return OAL_STATUS_SUCCESS;
2083 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2084 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2085 int len, oal_gatt_auth_req_t auth_req, char* data)
2087 int ret = OAL_STATUS_SUCCESS;
2088 char uuid_str1[2*BT_UUID_STRING_MAX];
2089 char uuid_str2[2*BT_UUID_STRING_MAX];
2090 OAL_CHECK_PARAMETER(srvc_id, return);
2091 OAL_CHECK_PARAMETER(char_id, return);
2092 OAL_CHECK_PARAMETER(data, return);
2093 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2094 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2095 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2096 CHECK_OAL_GATT_ENABLED();
2097 CHECK_CLIENT_CONNECTION(conn_id);
2099 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2100 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2101 if (ret != BT_STATUS_SUCCESS) {
2102 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2103 return convert_to_oal_status(ret);
2106 return OAL_STATUS_SUCCESS;
2109 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2110 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2111 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2113 int ret = OAL_STATUS_SUCCESS;
2114 char uuid_str1[2*BT_UUID_STRING_MAX];
2115 char uuid_str2[2*BT_UUID_STRING_MAX];
2116 char uuid_str3[2*BT_UUID_STRING_MAX];
2117 OAL_CHECK_PARAMETER(srvc_id, return);
2118 OAL_CHECK_PARAMETER(char_id, return);
2119 OAL_CHECK_PARAMETER(desc_id, return);
2120 OAL_CHECK_PARAMETER(data, return);
2121 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2122 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2123 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2124 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2125 uuid_str1, uuid_str2, uuid_str3);
2126 CHECK_OAL_GATT_ENABLED();
2127 CHECK_CLIENT_CONNECTION(conn_id);
2129 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2130 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2131 if (ret != BT_STATUS_SUCCESS) {
2132 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2133 return convert_to_oal_status(ret);
2136 return OAL_STATUS_SUCCESS;
2139 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2144 OAL_CHECK_PARAMETER(address, return);
2145 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2146 CHECK_OAL_GATT_ENABLED();
2148 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2149 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2150 if (ret != BT_STATUS_SUCCESS) {
2151 BT_ERR("error: %s", status2string(ret));
2152 return convert_to_oal_status(ret);
2154 return OAL_STATUS_SUCCESS;