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);
216 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id);
217 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu);
219 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
220 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
221 .register_client_cb = cb_gattc_register_app,
222 .scan_result_cb = cb_gattc_scan_result,
223 .open_cb = cb_gattc_connection,
224 .close_cb = cb_gattc_disconnect,
225 .search_complete_cb = cb_gattc_search_complete,
226 .search_result_cb = cb_gattc_search_result,
227 .get_characteristic_cb = cb_gattc_get_characteristics,
228 .get_descriptor_cb = cb_gattc_get_descriptor,
229 .get_included_service_cb = NULL,
230 .register_for_notification_cb = cb_gattc_register_for_notification,
231 .notify_cb = cb_gattc_notify,
232 .service_changed_cb = cb_gattc_service_changed,
233 .read_characteristic_cb = cb_gattc_read_characteristic,
234 .write_characteristic_cb = cb_gattc_write_characteristic,
235 .read_descriptor_cb = cb_gattc_read_descriptor,
236 .write_descriptor_cb = cb_gattc_write_descriptor,
237 .execute_write_cb = NULL,
238 .read_remote_rssi_cb = NULL,
239 .configure_mtu_cb = cb_gattc_configure_mtu_cmpl,
240 #ifdef PLATFORM_ANDROID_HAL
241 .scan_filter_cfg_cb = NULL,
242 .scan_filter_param_cb = NULL,
243 .scan_filter_status_cb = NULL,
244 .congestion_cb = NULL,
245 .batchscan_cfg_storage_cb = NULL,
246 .batchscan_enb_disable_cb = NULL,
247 .batchscan_reports_cb = NULL,
248 .batchscan_threshold_cb = NULL,
249 .track_adv_event_cb = NULL,
253 static btgatt_callbacks_t btgatt_callbacks = {
254 sizeof(btgatt_callbacks_t),
255 &btgatt_client_callbacks,
256 &btgatt_server_callbacks
259 /*******************************GATT Initialisation - Deinitialisation********************************/
260 oal_status_t gatt_enable(void)
262 const bt_interface_t * blued_api;
266 for (i = 0; i < NUM_SERVER_INST; i++) {
267 gatt_servers[i].server_id = -1;
268 gatt_servers[i].state = GATT_INS_DISABLED;
269 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
270 cur_adv_state[i] = FALSE;
273 /* Get stack interface */
274 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
276 if (blued_api == NULL) {
277 BT_ERR("Stack is not initialized");
278 return OAL_STATUS_NOT_READY;
282 BT_WARN("GATT Interface is already initialized...");
283 return OAL_STATUS_ALREADY_DONE;
286 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
287 if (gatt_api == NULL) {
288 BT_ERR("GATT interface failed");
289 return OAL_STATUS_INTERNAL_ERROR;
292 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
293 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
296 return convert_to_oal_status(ret);
299 BT_INFO("GATT successfully initialized");
300 return OAL_STATUS_SUCCESS;
303 oal_status_t gatt_disable(void)
311 for (i = 0; i < NUM_SERVER_INST; i++) {
312 gatt_servers[i].server_id = -1;
313 gatt_servers[i].state = GATT_INS_DISABLED;
314 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
316 return OAL_STATUS_SUCCESS;
319 /************************************GATT Server Functions*************************************/
321 oal_status_t gatts_register(oal_uuid_t* server_uuid)
323 char str[2*BT_UUID_STRING_MAX];
324 int ret = OAL_STATUS_SUCCESS;
327 CHECK_OAL_GATT_ENABLED();
328 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
329 API_TRACE("Register the server instance: UUID: [%s]", str);
331 for (i = 0; i < NUM_SERVER_INST; i++) {
332 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
333 if (gatt_servers[i].server_id != -1) {
334 BT_ERR("This is resevered UUID for easy set up application i = %d \
335 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
336 return OAL_STATUS_ALREADY_DONE;
341 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
343 if (ret != BT_STATUS_SUCCESS) {
344 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
345 return convert_to_oal_status(ret);
347 return OAL_STATUS_SUCCESS;
350 oal_status_t gatts_unregister(int instance_id)
352 int ret = OAL_STATUS_SUCCESS;
353 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
355 CHECK_OAL_GATT_ENABLED();
356 CHECK_SERVER_INSTANCE(instance_id);
357 CHECK_SERVER_REGISTRATION(instance_id);
359 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
361 if (ret != BT_STATUS_SUCCESS) {
362 BT_ERR("GATT server unregistration failed: %d", instance_id);
363 return convert_to_oal_status(ret);
366 gatt_servers[instance_id-1].server_id = -1;
367 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
369 if (instance_id != 1 && instance_id != 2)
370 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
372 return OAL_STATUS_SUCCESS;
375 /* Legacy Advertisement */
376 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
378 int ret = OAL_STATUS_SUCCESS;
379 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
381 CHECK_OAL_GATT_ENABLED();
382 CHECK_SERVER_INSTANCE(instance_id);
383 CHECK_SERVER_REGISTRATION(instance_id);
385 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
387 if (ret != BT_STATUS_SUCCESS) {
388 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
389 gatt_servers[instance_id-1].server_id, status2string(ret));
390 return convert_to_oal_status(ret);
393 return OAL_STATUS_SUCCESS;
396 oal_status_t gatts_stop_advertising(int instance_id)
398 int ret = OAL_STATUS_SUCCESS;
399 API_TRACE("Stop advertising");
401 CHECK_OAL_GATT_ENABLED();
402 CHECK_SERVER_INSTANCE(instance_id);
403 CHECK_SERVER_REGISTRATION(instance_id);
405 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
407 if (ret != BT_STATUS_SUCCESS) {
408 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
409 instance_id, status2string(ret));
410 return convert_to_oal_status(ret);
412 return OAL_STATUS_SUCCESS;
416 /* Below API's need to be removed as they are hardcoded API's.
417 If at all, product specific API's are required to set specific data, then new naming should
418 be adopted for these API's */
419 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
421 int ret = OAL_STATUS_SUCCESS;
423 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
424 CHECK_OAL_GATT_ENABLED();
425 CHECK_SERVER_INSTANCE(instance_id);
426 CHECK_SERVER_REGISTRATION(instance_id);
428 /* Historically used for Legacy Advertising */
429 return OAL_STATUS_NOT_SUPPORT;
432 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
434 int ret = OAL_STATUS_SUCCESS;
436 API_TRACE("Set advertising data");
437 CHECK_OAL_GATT_ENABLED();
438 CHECK_SERVER_INSTANCE(instance_id);
439 CHECK_SERVER_REGISTRATION(instance_id);
441 /* Historically used for Legacy Advertising */
442 return OAL_STATUS_NOT_SUPPORT;
445 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
447 int ret = OAL_STATUS_SUCCESS;
449 API_TRACE("Set Scan Response data");
450 CHECK_OAL_GATT_ENABLED();
451 CHECK_SERVER_INSTANCE(instance_id);
452 CHECK_SERVER_REGISTRATION(instance_id);
454 /* Historically used for Legacy Advertising */
455 return OAL_STATUS_NOT_SUPPORT;
459 oal_status_t gatts_multi_adv_enable(int instance_id)
461 int ret = OAL_STATUS_SUCCESS;
462 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
463 gatt_servers[instance_id - 1].server_id, instance_id);
465 CHECK_OAL_GATT_ENABLED();
466 CHECK_SERVER_INSTANCE(instance_id);
467 CHECK_SERVER_REGISTRATION(instance_id);
469 if (gatt_api->server->multi_adv_enable == NULL)
470 return OAL_STATUS_NOT_SUPPORT;
472 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
473 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
474 BT_ERR("Not allowed, state: %d, instance_id: %d",
475 gatt_servers[instance_id - 1].state, instance_id);
476 return OAL_STATUS_BUSY;
479 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
480 BT_ERR("Not allowed, state: %d, instance_id: %d",
481 gatt_servers[instance_id - 1].state, instance_id);
482 return OAL_STATUS_ALREADY_DONE;
485 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
486 BT_ERR("Not allowed, state: %d, instance_id: %d",
487 gatt_servers[instance_id - 1].state, instance_id);
488 return OAL_STATUS_BUSY;
491 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
493 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
495 if (ret != BT_STATUS_SUCCESS) {
496 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
497 instance_id, status2string(ret));
498 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
499 return convert_to_oal_status(ret);
501 return OAL_STATUS_SUCCESS;
504 oal_status_t gatts_multi_adv_disable(int instance_id)
506 int ret = OAL_STATUS_SUCCESS;
507 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
508 gatt_servers[instance_id - 1].server_id, instance_id);
510 CHECK_OAL_GATT_ENABLED();
511 CHECK_SERVER_INSTANCE(instance_id);
512 CHECK_SERVER_REGISTRATION(instance_id);
514 if (gatt_api->server->multi_adv_disable == NULL)
515 return OAL_STATUS_NOT_SUPPORT;
517 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
518 BT_ERR("Not Allowed, state: %d, instance_id: %d",
519 gatt_servers[instance_id - 1].state, instance_id);
520 return OAL_STATUS_BUSY;
523 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
525 if (ret != BT_STATUS_SUCCESS) {
526 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
527 instance_id, status2string(ret));
528 return convert_to_oal_status(ret);
530 return OAL_STATUS_SUCCESS;
533 oal_status_t gatts_set_filter_policy(int filter_policy)
535 int ret = OAL_STATUS_SUCCESS;
537 CHECK_OAL_GATT_ENABLED();
539 /* send the filter_policy value to the HAL Layer */
540 ret = gatt_api->server->set_filter_policy(filter_policy);
542 if (ret != BT_STATUS_SUCCESS) {
543 BT_ERR("set_filter_policy failed: %d",ret);
544 return convert_to_oal_status(ret);
547 return OAL_STATUS_SUCCESS;
550 oal_status_t gatts_multi_adv_update(int instance_id,
551 int min_intv, int max_intv,
552 int adv_type, int chnl_map,
553 int tx_power, int timeout_s)
555 int ret = OAL_STATUS_SUCCESS;
556 API_TRACE("Multi advertising Update");
558 CHECK_OAL_GATT_ENABLED();
559 CHECK_SERVER_INSTANCE(instance_id);
560 CHECK_SERVER_REGISTRATION(instance_id);
562 if (gatt_api->server->multi_adv_update == NULL)
563 return OAL_STATUS_NOT_SUPPORT;
565 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
568 tx_power, timeout_s);
570 if (ret != BT_STATUS_SUCCESS) {
571 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
572 instance_id, status2string(ret));
573 return convert_to_oal_status(ret);
575 return OAL_STATUS_SUCCESS;
578 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
579 oal_ble_multi_adv_param_setup_t *adv_param_setup)
581 int ret = OAL_STATUS_SUCCESS;
582 btgatt_adv_param_setup_t adv_setup;
583 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
584 gatt_servers[instance_id - 1].server_id, instance_id);
586 CHECK_OAL_GATT_ENABLED();
587 CHECK_SERVER_INSTANCE(instance_id);
588 CHECK_SERVER_REGISTRATION(instance_id);
590 if (gatt_api->server->multi_adv_set_inst_data == NULL)
591 return OAL_STATUS_NOT_SUPPORT;
593 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
594 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
595 return OAL_STATUS_BUSY;
598 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
601 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
602 adv_setup.include_name = adv_param_setup->include_name;
603 adv_setup.include_txpower = adv_param_setup->include_txpower;
604 adv_setup.appearance = adv_param_setup->appearance;
605 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
606 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
607 adv_setup.service_data = adv_param_setup->service_data;
608 adv_setup.service_data_len = adv_param_setup->service_data_len;
609 adv_setup.service_uuid = adv_param_setup->service_uuid;
610 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
611 /* Solicit UUID handler: Start */
612 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
613 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
614 /* Solicit UUID handler: End */
615 adv_setup.min_interval = adv_param_setup->min_interval;
616 adv_setup.max_interval = adv_param_setup->min_interval;
617 adv_setup.adv_type = adv_param_setup->adv_type;
618 adv_setup.chnl_map = adv_param_setup->chnl_map;
619 adv_setup.tx_power = adv_param_setup->tx_power;
620 adv_setup.timeout_s = adv_param_setup->timeout_s;
622 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
624 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
625 if (ret != BT_STATUS_SUCCESS) {
626 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
627 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
628 return convert_to_oal_status(ret);
630 return OAL_STATUS_SUCCESS;
633 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
635 int ret = OAL_STATUS_SUCCESS;
638 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
640 CHECK_OAL_GATT_ENABLED();
641 CHECK_SERVER_INSTANCE(instance_id);
642 CHECK_SERVER_REGISTRATION(instance_id);
644 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
646 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
647 if (ret != BT_STATUS_SUCCESS) {
648 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
649 return convert_to_oal_status(ret);
651 return OAL_STATUS_SUCCESS;
655 /************************************GATT Server Functions*************************************/
657 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
660 char str[2*BT_UUID_STRING_MAX];
661 uuid_to_stringname((service_uuid_t*)uuid, str);
663 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
665 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
666 BT_INFO("UUID: [%s]", str);
668 for (i = 0; i < NUM_SERVER_INST; i++) {
669 if (gatt_servers[i].server_id == -1) {
670 BT_INFO("Server Instance registered with stack [%d]", i+1);
671 gatt_servers[i].server_id = server_if;
672 event->server_inst = i+1;
673 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
674 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
678 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
681 static void cb_gatts_listen(int status, int server_if)
683 gboolean prev_state[NUM_SERVER_INST];
685 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
688 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
689 if (gatt_servers[instance_id - 1].server_id == server_if) {
690 event->server_inst = instance_id;
693 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
696 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
697 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
698 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
699 cur_adv_state[event->server_inst - 1] = new_state;
701 BT_ERR("Invalid Callback...");
706 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
708 if (TRUE == new_state)
709 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
711 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
714 static void cb_gatts_multi_adv_enable(int server_if, int status)
717 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
718 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
721 if (status != BT_STATUS_SUCCESS)
722 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
724 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
725 if (gatt_servers[instance_id - 1].server_id == server_if) {
726 event->server_inst = instance_id;
727 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
731 BT_ERR("Invalid Interface, srv_if: %d", server_if);
732 event->server_inst = -1;
734 event->status = convert_to_oal_status(status);
735 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
738 static void cb_gatts_multi_adv_disable(int server_if, int status)
740 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
741 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
744 if (status != BT_STATUS_SUCCESS)
745 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
747 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
748 if (gatt_servers[instance_id - 1].server_id == server_if) {
749 event->server_inst = instance_id;
750 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
754 BT_ERR("Invalid Interface, srv_if: %d", server_if);
755 event->server_inst = -1;
757 event->status = convert_to_oal_status(status);
758 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
761 static void cb_gatts_multi_adv_update(int server_if, int status)
763 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
764 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
767 if (status != BT_STATUS_SUCCESS)
768 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
770 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
771 if (gatt_servers[instance_id - 1].server_id == server_if) {
772 event->server_inst = instance_id;
776 BT_ERR("Invalid Interface, srv_if: %d", server_if);
777 event->server_inst = -1;
779 event->status = convert_to_oal_status(status);
780 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
783 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
785 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
786 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
789 if (status != BT_STATUS_SUCCESS)
790 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
792 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
793 if (gatt_servers[instance_id - 1].server_id == server_if) {
794 event->server_inst = instance_id;
795 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
799 BT_ERR("Invalid Interface, srv_if: %d", server_if);
800 event->server_inst = -1;
802 event->status = convert_to_oal_status(status);
803 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
806 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
808 int ret = OAL_STATUS_SUCCESS;
809 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
810 CHECK_OAL_GATT_ENABLED();
811 OAL_CHECK_PARAMETER(mtu, return);
813 /* To prevent crash in case other libraries not support this api */
814 if (gatt_api->server->get_att_mtu == NULL) {
815 BT_WARN("get_att_mtu is NULL");
816 return OAL_STATUS_NOT_SUPPORT;
819 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
820 if (ret != BT_STATUS_SUCCESS) {
821 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
822 return convert_to_oal_status(ret);
825 BT_INFO("Current ATT MTU Size: %d", *mtu);
826 return OAL_STATUS_SUCCESS;
828 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
829 int status, int fd, int mtu , void * fdlist)
831 int ret = OAL_STATUS_SUCCESS;
833 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
834 CHECK_OAL_GATT_ENABLED();
836 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
837 if (ret != BT_STATUS_SUCCESS) {
838 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
839 return convert_to_oal_status(ret);
841 return OAL_STATUS_SUCCESS;
844 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
847 int ret = OAL_STATUS_SUCCESS;
848 btgatt_srvc_id_t btgatt_srvc_id;
849 char str[2*BT_UUID_STRING_MAX];
851 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
852 CHECK_OAL_GATT_ENABLED();
854 CHECK_SERVER_INSTANCE(instance_id);
855 CHECK_SERVER_REGISTRATION(instance_id);
857 if (gatt_serv_id != NULL) {
858 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
859 API_TRACE("Service uuid: [%s]", str);
860 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
861 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
862 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
864 BT_INFO("GATT Server Service Id is NULL");
865 return OAL_STATUS_INVALID_PARAM;
868 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
870 if (ret != BT_STATUS_SUCCESS) {
871 BT_ERR("GATT Server add service failed: %s", status2string(ret));
872 return convert_to_oal_status(ret);
874 return OAL_STATUS_SUCCESS;
877 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
880 int ret = OAL_STATUS_SUCCESS;
881 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
882 instance_id, serv_handle, incl_handle);
883 CHECK_OAL_GATT_ENABLED();
885 CHECK_SERVER_INSTANCE(instance_id);
887 CHECK_SERVER_REGISTRATION(instance_id);
889 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
890 if (ret != BT_STATUS_SUCCESS) {
891 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
892 return convert_to_oal_status(ret);
894 return OAL_STATUS_SUCCESS;
897 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
898 oal_uuid_t* charc_uuid, int propts, int permsn)
900 int ret = OAL_STATUS_SUCCESS;
901 char str[2*BT_UUID_STRING_MAX];
902 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
903 char_prop_to_string(propts, prop);
904 char_perm_to_string(permsn, perm);
905 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
906 instance_id, serv_handle, prop, perm);
907 CHECK_OAL_GATT_ENABLED();
909 CHECK_SERVER_INSTANCE(instance_id);
911 CHECK_SERVER_REGISTRATION(instance_id);
913 if (charc_uuid != NULL) {
914 uuid_to_stringname(charc_uuid, str);
915 API_TRACE("uuid: [%s]", str);
918 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
919 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
920 if (ret != BT_STATUS_SUCCESS) {
921 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
922 return convert_to_oal_status(ret);
924 return OAL_STATUS_SUCCESS;
927 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
928 oal_uuid_t* desc_uuid, int permsn)
930 int ret = OAL_STATUS_SUCCESS;
931 char str[2*BT_UUID_STRING_MAX];
932 char perm[MAX_PERM_LEN];
933 char_perm_to_string(permsn, perm);
934 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
935 instance_id, serv_handle, perm);
936 CHECK_OAL_GATT_ENABLED();
938 CHECK_SERVER_INSTANCE(instance_id);
940 CHECK_SERVER_REGISTRATION(instance_id);
942 if (desc_uuid != NULL) {
943 uuid_to_stringname(desc_uuid, str);
944 API_TRACE("uuid: [%s]", str);
947 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
948 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
950 if (ret != BT_STATUS_SUCCESS) {
951 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
952 return convert_to_oal_status(ret);
954 return OAL_STATUS_SUCCESS;
957 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
959 int ret = OAL_STATUS_SUCCESS;
961 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
962 instance_id, svc_handle, transport);
963 CHECK_OAL_GATT_ENABLED();
965 CHECK_SERVER_INSTANCE(instance_id);
967 CHECK_SERVER_REGISTRATION(instance_id);
969 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
971 if (ret != BT_STATUS_SUCCESS) {
972 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
973 return convert_to_oal_status(ret);
975 return OAL_STATUS_SUCCESS;
978 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
980 int ret = OAL_STATUS_SUCCESS;
982 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
983 CHECK_OAL_GATT_ENABLED();
985 CHECK_SERVER_INSTANCE(ins_id);
986 CHECK_SERVER_REGISTRATION(ins_id);
988 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
989 if (ret != BT_STATUS_SUCCESS) {
990 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
991 return convert_to_oal_status(ret);
993 return OAL_STATUS_SUCCESS;
996 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
998 int ret = OAL_STATUS_SUCCESS;
1000 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1001 CHECK_OAL_GATT_ENABLED();
1003 CHECK_SERVER_INSTANCE(ins_id);
1005 CHECK_SERVER_REGISTRATION(ins_id);
1007 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
1008 if (ret != BT_STATUS_SUCCESS) {
1009 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1010 return convert_to_oal_status(ret);
1012 return OAL_STATUS_SUCCESS;
1015 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1017 int ret = OAL_STATUS_SUCCESS;
1019 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1020 CHECK_OAL_GATT_ENABLED();
1022 if (response == NULL) {
1023 BT_ERR("GATT Server attribute value is empty");
1024 return OAL_STATUS_INVALID_PARAM;
1027 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1028 if (ret != BT_STATUS_SUCCESS) {
1029 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1030 return convert_to_oal_status(ret);
1032 return OAL_STATUS_SUCCESS;
1035 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1037 int ret = OAL_STATUS_SUCCESS;
1039 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1040 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1041 CHECK_OAL_GATT_ENABLED();
1043 CHECK_SERVER_INSTANCE(ins_id);
1045 CHECK_SERVER_REGISTRATION(ins_id);
1047 if (value == NULL || len == 0) {
1048 BT_ERR("GATT Server attribute value is empty");
1049 return OAL_STATUS_INVALID_PARAM;
1052 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1053 attr_hndl, conn_id, len, confirm, value);
1055 if (ret != BT_STATUS_SUCCESS) {
1056 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1057 return convert_to_oal_status(ret);
1059 return OAL_STATUS_SUCCESS;
1062 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1064 int ret = OAL_STATUS_SUCCESS;
1066 CHECK_OAL_GATT_ENABLED();
1068 CHECK_SERVER_INSTANCE(ins_id);
1070 CHECK_SERVER_REGISTRATION(ins_id);
1072 if (value == NULL || value->len == 0) {
1073 BT_ERR("GATT Server attribute value is empty");
1074 return OAL_STATUS_INVALID_PARAM;
1077 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1078 ins_id, value->handle, value->len);
1080 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1081 (int)value->handle, (int)value->len, (char*)value->value);
1083 if (ret != BT_STATUS_SUCCESS) {
1084 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1085 return convert_to_oal_status(ret);
1087 return OAL_STATUS_SUCCESS;
1090 /* GATT Server Callbacks:Start */
1091 static void cb_gatts_service_added(int status, int server_if,
1092 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1096 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1097 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1099 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1101 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1102 event->gatt_srvc_stat.server_inst = -1;
1104 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1105 if (psrvc_id != NULL) {
1106 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1107 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1108 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1109 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1112 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1114 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1117 static void cb_gatts_included_service_added(int status, int server_if,
1119 int incl_srvc_handle)
1122 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1123 status, srvc_handle, incl_srvc_handle);
1125 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1127 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1129 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1130 event->gatt_srvc_stat.server_inst = -1;
1132 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1133 event->incl_srvc_hndl = incl_srvc_handle;
1134 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1135 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1138 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1139 int srvc_handle, int char_handle)
1143 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1144 status, srvc_handle, char_handle);
1146 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1148 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1150 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1151 event->gatt_srvc_stat.server_inst = -1;
1153 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1154 event->charctr_hndl = char_handle;
1155 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1156 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1157 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1160 static void cb_gatts_descriptor_added(int status, int server_if,
1161 bt_uuid_t *descr_id, int srvc_handle,
1165 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1166 status, srvc_handle, descr_handle);
1168 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1170 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1172 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1173 event->gatt_srvc_stat.server_inst = -1;
1175 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1176 event->descrptr_hndl = descr_handle;
1177 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1178 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1179 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1182 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1185 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1187 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1189 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1191 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1192 event->server_inst = -1;
1194 event->servic_hndl = srvc_handle;
1195 event->status = convert_to_oal_status(status);
1196 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1199 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1202 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1204 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1206 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1208 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1209 event->server_inst = -1;
1211 event->servic_hndl = srvc_handle;
1212 event->status = convert_to_oal_status(status);
1213 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1216 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1219 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1221 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1223 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1225 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1226 event->server_inst = -1;
1228 event->servic_hndl = srvc_handle;
1229 event->status = convert_to_oal_status(status);
1230 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1233 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1236 oal_event_t event_type;
1238 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1239 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1241 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1242 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1243 event->server_inst = ins_id;
1246 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1249 if (ins_id == NUM_SERVER_INST+1) {
1250 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1254 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1255 event->conn_id = conn_id;
1256 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1257 event->status = OAL_STATUS_SUCCESS;
1259 send_event(event_type, event, sizeof(event_gatts_conn_t));
1262 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1263 int attr_handle, int offset, bool is_long)
1265 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1267 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1269 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1271 event->attr_trans.attr_handle = attr_handle;
1272 event->attr_trans.conn_id = conn_id;
1273 event->attr_trans.trans_id = trans_id;
1274 event->attr_trans.offset = offset;
1275 event->is_long = is_long;
1277 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1280 static void cb_gatts_request_write(int conn_id, int trans_id,
1281 bt_bdaddr_t *bda, int attr_handle,
1282 int offset, int length,
1283 bool need_rsp, bool is_prep, uint8_t* value)
1285 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1287 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1289 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1291 event->attr_trans.attr_handle = attr_handle;
1292 event->attr_trans.conn_id = conn_id;
1293 event->attr_trans.trans_id = trans_id;
1294 event->attr_trans.offset = offset;
1295 event->need_rsp = need_rsp;
1296 event->is_prep = is_prep;
1298 if (length > 0 && value != NULL) {
1299 if (length > OAL_GATT_MAX_ATTR_LEN)
1300 length = OAL_GATT_MAX_ATTR_LEN;
1301 memcpy(event->value, value, length);
1302 event->length = length;
1304 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1307 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1310 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1312 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1314 event->attr_trans.attr_handle = attr_handle;
1315 event->attr_trans.conn_id = conn_id;
1316 event->attr_trans.trans_id = trans_id;
1318 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1320 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1323 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1325 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1327 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1329 event->attr_trans.attr_handle = attr_handle;
1330 event->attr_trans.conn_id = conn_id;
1331 event->attr_trans.trans_id = trans_id;
1334 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1338 static void cb_gatts_response_confirmation(int status, int handle)
1340 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1342 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1344 event->hndl = handle;
1345 event->status = convert_to_oal_status(status);
1347 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1350 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1352 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1353 conn_id, trans_id, attr_handle);
1355 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1357 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1359 event->attr_handle = attr_handle;
1360 event->conn_id = conn_id;
1361 event->trans_id = trans_id;
1362 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1365 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1367 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1368 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1369 event->conn_id = conn_id;
1370 event->mtu_size = mtu;
1371 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1375 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1377 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1378 conn_id, trans_id, attr_handle, notify);
1380 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1382 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1384 event->attr_handle = attr_handle;
1385 event->conn_id = conn_id;
1386 event->trans_id = trans_id;
1387 event->notify = notify;
1388 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1393 /* GATT Server Callbacks: End */
1394 /************************************ GATT Client ***********************************/
1395 /* Client Callbacks */
1396 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1398 char uuid_str[BT_UUID_STRING_MAX];
1399 event_gattc_register_t *event;
1401 /* Check if GATT client registered for Default GATT client UUID */
1402 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1404 BT_INFO("GATT CLIENT REGISTER APP CB, status:%d, clientIf:%d, %s", status, clientIf, uuid_str);
1405 event = g_new0(event_gattc_register_t, 1);
1406 event->client_if = clientIf;
1407 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1408 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1409 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1412 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1414 event_ble_scan_result_info *event;
1416 event = g_new0(event_ble_scan_result_info, 1);
1418 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1419 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1420 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1421 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1424 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1426 event_gattc_conn_t *event;
1427 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1428 status, client_if, conn_id);
1430 event = g_new0(event_gattc_conn_t, 1);
1431 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1432 event->client_if = client_if;
1434 if (BT_STATUS_SUCCESS != status) {
1435 event->status = OAL_STATUS_INTERNAL_ERROR;
1436 BT_ERR("gattc connection Error: %d", status);
1438 event->conn_id = conn_id;
1439 event->status = OAL_STATUS_SUCCESS;
1442 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1443 sizeof(*event), (bt_address_t *)bda);
1447 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1449 event_gattc_conn_t *event;
1450 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1451 status, client_if, conn_id);
1452 event = g_new0(event_gattc_conn_t, 1);
1453 event->status = convert_to_oal_status(status);
1454 event->client_if = client_if;
1455 event->conn_id = conn_id;
1456 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1457 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1458 sizeof(*event), (bt_address_t *)bda);
1461 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1463 char uuid_str[2*BT_UUID_STRING_MAX];
1465 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1467 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1468 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1469 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1471 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1472 event->conn_status.status = OAL_STATUS_SUCCESS;
1473 event->conn_status.conn_id = conn_id;
1474 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1476 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1479 static void cb_gattc_search_complete(int conn_id, int status)
1481 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1484 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1485 event->conn_id = conn_id;
1486 event->status = convert_to_oal_status(status);
1488 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1492 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1493 btgatt_gatt_id_t *char_id, int char_prop)
1495 char uuid_str1[2*BT_UUID_STRING_MAX];
1496 char uuid_str2[2*BT_UUID_STRING_MAX];
1499 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1500 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1501 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1502 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1504 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1505 event->conn_status.conn_id = conn_id;
1506 event->conn_status.status = convert_to_oal_status(status);
1507 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1510 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1511 BT_INFO("Charac => [%s], Inst_id [%u], Prop [%s]",
1512 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1513 event->char_prop = char_prop;
1514 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1516 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1521 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)
1523 char uuid_str1[2*BT_UUID_STRING_MAX];
1524 char uuid_str2[2*BT_UUID_STRING_MAX];
1525 char uuid_str3[2*BT_UUID_STRING_MAX];
1526 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1527 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1528 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1529 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1530 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1531 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1533 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1534 event->conn_status.conn_id = conn_id;
1535 event->conn_status.status = convert_to_oal_status(status);
1536 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1537 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1540 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1541 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, descr_id->inst_id);
1542 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1544 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1547 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)
1549 char uuid_str1[2*BT_UUID_STRING_MAX];
1550 char uuid_str2[2*BT_UUID_STRING_MAX];
1551 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1552 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1553 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1554 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1555 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1556 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1558 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1559 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1560 event->client_if = client_if;
1561 event->status = convert_to_oal_status(status);
1562 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1563 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1565 send_event(event_type, event, sizeof(*event));
1568 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1571 char uuid_str1[2*BT_UUID_STRING_MAX];
1572 char uuid_str2[2*BT_UUID_STRING_MAX];
1574 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1575 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1576 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1578 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1579 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1581 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1582 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1583 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1585 if (p_data->len > 0) {
1587 data = g_malloc(3*p_data->len+1);
1589 BT_ERR("memory allocation failed");
1593 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1594 BT_INFO("Notified Data: [%s]", data);
1596 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1597 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1598 event->is_notify = p_data->is_notify;
1599 event->data_len = p_data->len;
1600 memcpy(event->data, p_data->value, event->data_len);
1601 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1602 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1604 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1609 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id)
1611 event_gattc_service_changed_data *event = g_new0(event_gattc_service_changed_data, 1);
1613 memcpy(event->address.addr, bd_addr->address, 6);
1614 event->change_type = change_type;
1615 memcpy(event->uuid.uuid, uuid, sizeof(event->uuid.uuid));
1616 event->conn_id = conn_id;
1618 send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
1621 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1623 char uuid_str1[2*BT_UUID_STRING_MAX];
1624 char uuid_str2[2*BT_UUID_STRING_MAX];
1625 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1627 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1628 event->uuid_status.conn_status.conn_id = conn_id;
1629 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1630 event->value_type = p_data->value_type;
1631 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1632 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1634 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1635 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1636 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1637 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1638 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1639 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1640 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1642 data = g_malloc(3*p_data->value.len+1);
1644 BT_ERR("memory allocation failed");
1648 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1649 BT_DBG("Read Data: [%s]", data);
1650 event->data_len = p_data->value.len;
1651 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1655 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1658 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1660 char uuid_str1[2*BT_UUID_STRING_MAX];
1661 char uuid_str2[2*BT_UUID_STRING_MAX];
1662 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1664 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1665 event->conn_status.conn_id = conn_id;
1666 event->conn_status.status = convert_to_oal_status(status);
1667 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1668 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1670 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1671 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1672 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1673 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1674 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1676 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1679 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1681 char uuid_str1[2*BT_UUID_STRING_MAX];
1682 char uuid_str2[2*BT_UUID_STRING_MAX];
1683 char uuid_str3[2*BT_UUID_STRING_MAX];
1684 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1686 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1687 event->conn_status.conn_id = conn_id;
1688 event->conn_status.status = convert_to_oal_status(status);
1689 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1690 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1691 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1693 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1694 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1695 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1696 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1697 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1698 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1699 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1701 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1706 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1708 char uuid_str1[2*BT_UUID_STRING_MAX];
1709 char uuid_str2[2*BT_UUID_STRING_MAX];
1710 char uuid_str3[2*BT_UUID_STRING_MAX];
1711 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1713 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1714 event->uuid_status.conn_status.conn_id = conn_id;
1715 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1716 event->value_type = p_data->value_type;
1717 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1718 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1719 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1722 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1723 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1724 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1725 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1726 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1727 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1728 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1729 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1730 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1732 data = g_malloc(3*p_data->value.len+1);
1734 BT_ERR("memory allocation failed");
1738 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1739 BT_DBG("Read Data: [%s]", data);
1740 event->data_len = p_data->value.len;
1741 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1745 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1748 oal_status_t gattc_start_le_discovery(int client_id)
1751 int ret = OAL_STATUS_SUCCESS;
1753 API_TRACE("BTGATT CLIENT SCAN START");
1754 CHECK_OAL_GATT_ENABLED();
1755 CHECK_CLIENT_REGISTRATION(client_id);
1757 ret = gatt_api->client->scan(client_id, 1);
1758 if (ret != BT_STATUS_SUCCESS) {
1759 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1760 return convert_to_oal_status(ret);
1762 return OAL_STATUS_SUCCESS;
1765 oal_status_t gattc_stop_le_discovery(int client_id)
1768 int ret = OAL_STATUS_SUCCESS;
1770 API_TRACE("Scan is stopped");
1771 CHECK_OAL_GATT_ENABLED();
1772 CHECK_CLIENT_REGISTRATION(client_id);
1773 ret = gatt_api->client->scan(client_id, 0);
1774 if (ret != BT_STATUS_SUCCESS) {
1775 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1776 return convert_to_oal_status(ret);
1778 return OAL_STATUS_SUCCESS;
1781 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1785 API_TRACE("Scan is stopped");
1786 CHECK_OAL_GATT_ENABLED();
1789 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1790 if (ret != BT_STATUS_SUCCESS) {
1791 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1792 return convert_to_oal_status(ret);
1795 ret = gatt_api->client->set_scan_parameters(itv, win);
1796 if (ret != BT_STATUS_SUCCESS) {
1797 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1798 return convert_to_oal_status(ret);
1802 return OAL_STATUS_SUCCESS;
1805 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1807 event_gattc_mtu_configured_t *event;
1808 BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1809 conn_id, status, mtu);
1810 event = g_new0(event_gattc_mtu_configured_t, 1);
1811 event->conn_id = conn_id;
1813 event->status = convert_to_oal_status(status);
1814 send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1817 /************************************ GATT Client ***********************************/
1818 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1821 char str[2*BT_UUID_STRING_MAX];
1822 int ret = OAL_STATUS_SUCCESS;
1824 CHECK_OAL_GATT_ENABLED();
1825 uuid_to_stringname(client_uuid, str);
1826 API_TRACE("uuid: [%s]", str);
1827 /* We will perform actual registration in cb_gattc_register_app callback */
1828 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1829 if (ret != BT_STATUS_SUCCESS) {
1830 BT_ERR("GATT client register failed: %s", status2string(ret));
1831 return convert_to_oal_status(ret);
1833 return OAL_STATUS_SUCCESS;
1836 oal_status_t gattc_deregister(int client_id)
1838 int ret = OAL_STATUS_SUCCESS;
1840 API_TRACE("GATT client deregister");
1841 CHECK_OAL_GATT_ENABLED();
1842 CHECK_CLIENT_REGISTRATION(client_id);
1844 ret = gatt_api->client->unregister_client(client_id);
1845 if (ret != BT_STATUS_SUCCESS) {
1846 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1847 return convert_to_oal_status(ret);
1850 return OAL_STATUS_SUCCESS;
1853 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1855 int ret = OAL_STATUS_SUCCESS;
1858 OAL_CHECK_PARAMETER(device_address, return);
1859 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1860 CHECK_OAL_GATT_ENABLED();
1861 CHECK_CLIENT_REGISTRATION(client_id);
1863 /* Handle the actual connection in cb_gattc_connection callback */
1864 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1865 if (ret != BT_STATUS_SUCCESS) {
1866 BT_ERR("GATT client connect failed: %s", status2string(ret));
1867 return convert_to_oal_status(ret);
1869 return OAL_STATUS_SUCCESS;
1872 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1875 int ret = OAL_STATUS_SUCCESS;
1878 OAL_CHECK_PARAMETER(device_address, return);
1879 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1880 CHECK_OAL_GATT_ENABLED();
1881 CHECK_CLIENT_REGISTRATION(client_id);
1882 CHECK_CLIENT_CONNECTION(conn_id);
1884 /* Handle actual disconnection in callback */
1885 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1886 if (ret != BT_STATUS_SUCCESS) {
1887 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1888 return convert_to_oal_status(ret);
1890 return OAL_STATUS_SUCCESS;
1894 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1896 int ret = OAL_STATUS_SUCCESS;
1897 char uuid_str[2*BT_UUID_STRING_MAX];
1900 uuid_to_stringname(service_uuid, uuid_str);
1901 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1903 API_TRACE("Client Service Search All");
1905 CHECK_OAL_GATT_ENABLED();
1906 CHECK_CLIENT_CONNECTION(conn_id);
1907 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1909 if (ret != BT_STATUS_SUCCESS) {
1910 BT_ERR("GATT client service search failed: %s", status2string(ret));
1911 return convert_to_oal_status(ret);
1913 return OAL_STATUS_SUCCESS;
1916 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1918 int ret = OAL_STATUS_SUCCESS;
1919 char uuid_str[2*BT_UUID_STRING_MAX];
1921 OAL_CHECK_PARAMETER(srvc_id, return);
1922 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1923 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1924 CHECK_OAL_GATT_ENABLED();
1925 CHECK_CLIENT_CONNECTION(conn_id);
1926 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1927 (btgatt_gatt_id_t *)char_id);
1928 if (ret != BT_STATUS_SUCCESS) {
1929 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1930 return convert_to_oal_status(ret);
1932 return OAL_STATUS_SUCCESS;
1935 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1936 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1938 int ret = OAL_STATUS_SUCCESS;
1939 char uuid_str1[2*BT_UUID_STRING_MAX];
1940 char uuid_str2[2*BT_UUID_STRING_MAX];
1942 OAL_CHECK_PARAMETER(srvc_id, return);
1943 OAL_CHECK_PARAMETER(char_id, return);
1944 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1945 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1946 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1947 CHECK_OAL_GATT_ENABLED();
1948 CHECK_CLIENT_CONNECTION(conn_id);
1949 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1950 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1951 if (ret != BT_STATUS_SUCCESS) {
1952 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1953 return convert_to_oal_status(ret);
1955 return OAL_STATUS_SUCCESS;
1958 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1959 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1960 int ret = OAL_STATUS_SUCCESS;
1961 char uuid_str1[2*BT_UUID_STRING_MAX];
1962 char uuid_str2[2*BT_UUID_STRING_MAX];
1965 OAL_CHECK_PARAMETER(address, return);
1966 OAL_CHECK_PARAMETER(srvc_id, return);
1967 OAL_CHECK_PARAMETER(char_id, return);
1968 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1969 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1970 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1971 CHECK_OAL_GATT_ENABLED();
1972 CHECK_CLIENT_REGISTRATION(client_id);
1974 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);
1975 if (ret != BT_STATUS_SUCCESS) {
1976 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1977 return convert_to_oal_status(ret);
1980 return OAL_STATUS_SUCCESS;
1983 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1984 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1985 int ret = OAL_STATUS_SUCCESS;
1986 char uuid_str1[2*BT_UUID_STRING_MAX];
1987 char uuid_str2[2*BT_UUID_STRING_MAX];
1990 OAL_CHECK_PARAMETER(address, return);
1991 OAL_CHECK_PARAMETER(srvc_id, return);
1992 OAL_CHECK_PARAMETER(char_id, return);
1993 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1994 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1995 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1996 CHECK_OAL_GATT_ENABLED();
1997 CHECK_CLIENT_REGISTRATION(client_id);
1999 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);
2000 if (ret != BT_STATUS_SUCCESS) {
2001 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2002 return convert_to_oal_status(ret);
2005 return OAL_STATUS_SUCCESS;
2009 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2010 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2012 int ret = OAL_STATUS_SUCCESS;
2013 char uuid_str1[2*BT_UUID_STRING_MAX];
2014 char uuid_str2[2*BT_UUID_STRING_MAX];
2016 OAL_CHECK_PARAMETER(srvc_id, return);
2017 OAL_CHECK_PARAMETER(char_id, return);
2018 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2019 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2020 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2021 CHECK_OAL_GATT_ENABLED();
2022 CHECK_CLIENT_CONNECTION(conn_id);
2024 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2025 (btgatt_gatt_id_t *)char_id, auth_req);
2026 if (ret != BT_STATUS_SUCCESS) {
2027 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2028 return convert_to_oal_status(ret);
2031 return OAL_STATUS_SUCCESS;
2034 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2035 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2037 int ret = OAL_STATUS_SUCCESS;
2038 char uuid_str1[2*BT_UUID_STRING_MAX];
2039 char uuid_str2[2*BT_UUID_STRING_MAX];
2040 char uuid_str3[2*BT_UUID_STRING_MAX];
2042 OAL_CHECK_PARAMETER(srvc_id, return);
2043 OAL_CHECK_PARAMETER(char_id, return);
2044 OAL_CHECK_PARAMETER(desc_id, return);
2045 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2046 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2047 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2048 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2049 uuid_str1, uuid_str2, uuid_str3);
2050 CHECK_OAL_GATT_ENABLED();
2051 CHECK_CLIENT_CONNECTION(conn_id);
2053 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2054 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2055 if (ret != BT_STATUS_SUCCESS) {
2056 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2057 return convert_to_oal_status(ret);
2060 return OAL_STATUS_SUCCESS;
2063 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2064 oal_gatt_id_t *char_id, int *fd, int *mtu)
2066 int ret = OAL_STATUS_SUCCESS;
2067 char uuid_str1[2*BT_UUID_STRING_MAX];
2068 char uuid_str2[2*BT_UUID_STRING_MAX];
2069 OAL_CHECK_PARAMETER(srvc_id, return);
2070 OAL_CHECK_PARAMETER(char_id, return);
2071 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2072 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2073 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2074 CHECK_OAL_GATT_ENABLED();
2075 CHECK_CLIENT_CONNECTION(conn_id);
2077 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2078 (btgatt_gatt_id_t *)char_id, fd, mtu);
2079 if (ret != BT_STATUS_SUCCESS) {
2080 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2081 return convert_to_oal_status(ret);
2084 return OAL_STATUS_SUCCESS;
2087 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2088 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2090 int ret = OAL_STATUS_SUCCESS;
2091 char uuid_str1[2*BT_UUID_STRING_MAX];
2092 char uuid_str2[2*BT_UUID_STRING_MAX];
2093 OAL_CHECK_PARAMETER(srvc_id, return);
2094 OAL_CHECK_PARAMETER(char_id, return);
2095 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2096 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2097 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2098 CHECK_OAL_GATT_ENABLED();
2099 CHECK_CLIENT_CONNECTION(conn_id);
2101 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2102 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2103 if (ret != BT_STATUS_SUCCESS) {
2104 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2105 return convert_to_oal_status(ret);
2108 return OAL_STATUS_SUCCESS;
2111 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2112 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2113 int len, oal_gatt_auth_req_t auth_req, char* data)
2115 int ret = OAL_STATUS_SUCCESS;
2116 char uuid_str1[2*BT_UUID_STRING_MAX];
2117 char uuid_str2[2*BT_UUID_STRING_MAX];
2118 OAL_CHECK_PARAMETER(srvc_id, return);
2119 OAL_CHECK_PARAMETER(char_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 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2124 CHECK_OAL_GATT_ENABLED();
2125 CHECK_CLIENT_CONNECTION(conn_id);
2127 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2128 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2129 if (ret != BT_STATUS_SUCCESS) {
2130 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2131 return convert_to_oal_status(ret);
2134 return OAL_STATUS_SUCCESS;
2137 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2138 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2139 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2141 int ret = OAL_STATUS_SUCCESS;
2142 char uuid_str1[2*BT_UUID_STRING_MAX];
2143 char uuid_str2[2*BT_UUID_STRING_MAX];
2144 char uuid_str3[2*BT_UUID_STRING_MAX];
2145 OAL_CHECK_PARAMETER(srvc_id, return);
2146 OAL_CHECK_PARAMETER(char_id, return);
2147 OAL_CHECK_PARAMETER(desc_id, return);
2148 OAL_CHECK_PARAMETER(data, return);
2149 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2150 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2151 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2152 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2153 uuid_str1, uuid_str2, uuid_str3);
2154 CHECK_OAL_GATT_ENABLED();
2155 CHECK_CLIENT_CONNECTION(conn_id);
2157 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2158 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2159 if (ret != BT_STATUS_SUCCESS) {
2160 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2161 return convert_to_oal_status(ret);
2164 return OAL_STATUS_SUCCESS;
2167 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2172 OAL_CHECK_PARAMETER(address, return);
2173 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2174 CHECK_OAL_GATT_ENABLED();
2176 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2177 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2178 if (ret != BT_STATUS_SUCCESS) {
2179 BT_ERR("error: %s", status2string(ret));
2180 return convert_to_oal_status(ret);
2182 return OAL_STATUS_SUCCESS;
2185 oal_status_t gattc_unregister_scan_filter(int slot_id)
2191 CHECK_OAL_GATT_ENABLED();
2193 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2195 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2196 if (ret != BT_STATUS_SUCCESS) {
2197 BT_ERR("error: %s", status2string(ret));
2198 return convert_to_oal_status(ret);
2200 return OAL_STATUS_SUCCESS;
2203 oal_status_t gattc_enable_scan_filter(int client_if)
2208 CHECK_OAL_GATT_ENABLED();
2210 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2212 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2213 if (ret != BT_STATUS_SUCCESS) {
2214 BT_ERR("error: %s", status2string(ret));
2215 return convert_to_oal_status(ret);
2217 return OAL_STATUS_SUCCESS;
2220 oal_status_t gattc_disable_scan_filter(int client_if)
2225 CHECK_OAL_GATT_ENABLED();
2227 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2229 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2230 if (ret != BT_STATUS_SUCCESS) {
2231 BT_ERR("error: %s", status2string(ret));
2232 return convert_to_oal_status(ret);
2234 return OAL_STATUS_SUCCESS;
2237 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2240 int client_info = 0;
2243 int company_id_mask = 0;
2244 int address_type = 0;
2245 int feature_selection = 0;
2247 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2248 .filt_logic_type = 1,
2249 .rssi_high_thres = -127,
2250 .rssi_low_thres = -127,
2254 .found_timeout_cnt = 0
2257 OAL_CHECK_PARAMETER(filter_data, return);
2259 CHECK_OAL_GATT_ENABLED();
2261 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2263 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2264 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2265 ret = gatt_api->client->scan_filter_add_remove(client_info,
2267 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2268 filter_data->slot_id,
2273 (bt_bdaddr_t*)filter_data->device_address,
2280 if (ret != BT_STATUS_SUCCESS){
2281 BT_ERR("error: %s", status2string(ret));
2282 BT_INFO("unregistering already set filter features.");
2283 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2284 return convert_to_oal_status(ret);
2287 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2289 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2290 ret = gatt_api->client->scan_filter_add_remove(client_info,
2292 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2293 filter_data->slot_id,
2301 filter_data->device_name, // device_name as p_data in HAL
2305 if (ret != BT_STATUS_SUCCESS){
2306 BT_ERR("error: %s", status2string(ret));
2307 BT_INFO("unregistering already set filter features.");
2308 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2309 return convert_to_oal_status(ret);
2312 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2314 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2315 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2316 char uuid_str1[2*BT_UUID_STRING_MAX];
2317 char uuid_str2[2*BT_UUID_STRING_MAX];
2319 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2320 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2322 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2323 ret = gatt_api->client->scan_filter_add_remove(client_info,
2325 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2326 filter_data->slot_id,
2329 (bt_uuid_t*)filter_data->service_uuid,
2330 (bt_uuid_t*)filter_data->service_uuid_mask,
2333 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2335 filter_data->service_uuid_mask_len,
2338 if (ret != BT_STATUS_SUCCESS){
2339 BT_ERR("error: %s", status2string(ret));
2340 BT_INFO("unregistering already set filter features.");
2341 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2342 return convert_to_oal_status(ret);
2345 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2347 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2348 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2349 char uuid_str1[2*BT_UUID_STRING_MAX];
2350 char uuid_str2[2*BT_UUID_STRING_MAX];
2351 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2352 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2353 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2354 ret = gatt_api->client->scan_filter_add_remove(client_info,
2356 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2357 filter_data->slot_id,
2360 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2361 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2364 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2366 filter_data->service_solicitation_uuid_mask_len,
2369 if (ret != BT_STATUS_SUCCESS){
2370 BT_ERR("error: %s", status2string(ret));
2371 BT_INFO("unregistering already set filter features.");
2372 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2373 return convert_to_oal_status(ret);
2376 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2378 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2379 ret = gatt_api->client->scan_filter_add_remove(client_info,
2381 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2382 filter_data->slot_id,
2389 filter_data->service_data_len, //service_data_len as data_len in HAL
2390 (char*)filter_data->service_data,
2391 filter_data->service_data_mask_len,
2392 (char*)filter_data->service_data_mask
2394 if (ret != BT_STATUS_SUCCESS){
2395 BT_ERR("error: %s", status2string(ret));
2396 BT_INFO("unregistering already set filter features.");
2397 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2398 return convert_to_oal_status(ret);
2401 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2403 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2404 ret = gatt_api->client->scan_filter_add_remove(client_info,
2406 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2407 filter_data->slot_id,
2408 filter_data->manufacturer_id,
2414 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2415 (char*)filter_data->manufacturer_data,
2416 filter_data->manufacturer_data_mask_len,
2417 (char*)filter_data->manufacturer_data_mask
2419 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2420 if (ret != BT_STATUS_SUCCESS){
2421 BT_ERR("error: %s", status2string(ret));
2422 BT_INFO("unregistering already set filter features.");
2423 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2424 return convert_to_oal_status(ret);
2427 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2430 BT_DBG("Filter selection 0x%.2x", feature_selection);
2432 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2433 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2434 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2435 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2436 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2437 if (ret != BT_STATUS_SUCCESS){
2438 BT_ERR("error: %s", status2string(ret));
2439 return convert_to_oal_status(ret);
2441 return OAL_STATUS_SUCCESS;
2444 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2448 API_TRACE("Configure MTU Size: [%d]", mtu);
2449 CHECK_OAL_GATT_ENABLED();
2450 CHECK_CLIENT_CONNECTION(conn_id);
2452 /* To prevent crash in case other libraries not support this api */
2453 if (gatt_api->client->configure_mtu == NULL) {
2454 BT_WARN("configure_mtu is NULL");
2455 return OAL_STATUS_NOT_SUPPORT;
2458 ret = gatt_api->client->configure_mtu(conn_id, mtu);
2459 if (ret != BT_STATUS_SUCCESS) {
2460 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2461 return convert_to_oal_status(ret);
2463 return OAL_STATUS_SUCCESS;
2466 oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int server_inst_id)
2468 int ret = OAL_STATUS_SUCCESS;
2471 OAL_CHECK_PARAMETER(device_address, return);
2472 API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
2473 CHECK_OAL_GATT_ENABLED();
2474 CHECK_SERVER_INSTANCE(server_inst_id);
2475 CHECK_SERVER_REGISTRATION(server_inst_id);
2477 ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, server_inst_id);
2478 if (ret != BT_STATUS_SUCCESS) {
2479 BT_ERR("GATT connection info add failed: %s", status2string(ret));
2480 return convert_to_oal_status(ret);
2482 return OAL_STATUS_SUCCESS;