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, uint8_t addr_type, int rssi,
201 uint8_t *adv_data, int adv_data_len, uint8_t *scan_rsp_data, int scan_rsp_data_len);
202 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
203 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
204 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
205 static void cb_gattc_search_complete(int conn_id, int status);
206 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
207 btgatt_gatt_id_t *char_id, int char_prop);
208 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
209 btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
210 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
211 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
212 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
213 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
214 static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
215 btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
216 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
217 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id);
218 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu);
220 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
221 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
222 .register_client_cb = cb_gattc_register_app,
223 .scan_result_cb = cb_gattc_scan_result,
224 .open_cb = cb_gattc_connection,
225 .close_cb = cb_gattc_disconnect,
226 .search_complete_cb = cb_gattc_search_complete,
227 .search_result_cb = cb_gattc_search_result,
228 .get_characteristic_cb = cb_gattc_get_characteristics,
229 .get_descriptor_cb = cb_gattc_get_descriptor,
230 .get_included_service_cb = NULL,
231 .register_for_notification_cb = cb_gattc_register_for_notification,
232 .notify_cb = cb_gattc_notify,
233 .service_changed_cb = cb_gattc_service_changed,
234 .read_characteristic_cb = cb_gattc_read_characteristic,
235 .write_characteristic_cb = cb_gattc_write_characteristic,
236 .read_descriptor_cb = cb_gattc_read_descriptor,
237 .write_descriptor_cb = cb_gattc_write_descriptor,
238 .execute_write_cb = NULL,
239 .read_remote_rssi_cb = NULL,
240 .configure_mtu_cb = cb_gattc_configure_mtu_cmpl,
241 #ifdef PLATFORM_ANDROID_HAL
242 .scan_filter_cfg_cb = NULL,
243 .scan_filter_param_cb = NULL,
244 .scan_filter_status_cb = NULL,
245 .congestion_cb = NULL,
246 .batchscan_cfg_storage_cb = NULL,
247 .batchscan_enb_disable_cb = NULL,
248 .batchscan_reports_cb = NULL,
249 .batchscan_threshold_cb = NULL,
250 .track_adv_event_cb = NULL,
254 static btgatt_callbacks_t btgatt_callbacks = {
255 sizeof(btgatt_callbacks_t),
256 &btgatt_client_callbacks,
257 &btgatt_server_callbacks
260 /*******************************GATT Initialisation - Deinitialisation********************************/
261 oal_status_t gatt_enable(void)
263 const bt_interface_t * blued_api;
267 for (i = 0; i < NUM_SERVER_INST; i++) {
268 gatt_servers[i].server_id = -1;
269 gatt_servers[i].state = GATT_INS_DISABLED;
270 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
271 cur_adv_state[i] = FALSE;
274 /* Get stack interface */
275 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
277 if (blued_api == NULL) {
278 BT_ERR("Stack is not initialized");
279 return OAL_STATUS_NOT_READY;
283 BT_WARN("GATT Interface is already initialized...");
284 return OAL_STATUS_ALREADY_DONE;
287 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
288 if (gatt_api == NULL) {
289 BT_ERR("GATT interface failed");
290 return OAL_STATUS_INTERNAL_ERROR;
293 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
294 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
297 return convert_to_oal_status(ret);
300 BT_INFO("GATT successfully initialized");
301 return OAL_STATUS_SUCCESS;
304 oal_status_t gatt_disable(void)
312 for (i = 0; i < NUM_SERVER_INST; i++) {
313 gatt_servers[i].server_id = -1;
314 gatt_servers[i].state = GATT_INS_DISABLED;
315 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
317 return OAL_STATUS_SUCCESS;
320 /************************************GATT Server Functions*************************************/
322 oal_status_t gatts_register(oal_uuid_t* server_uuid)
324 char str[2*BT_UUID_STRING_MAX];
325 int ret = OAL_STATUS_SUCCESS;
328 CHECK_OAL_GATT_ENABLED();
329 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
330 API_TRACE("Register the server instance: UUID: [%s]", str);
332 for (i = 0; i < NUM_SERVER_INST; i++) {
333 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
334 if (gatt_servers[i].server_id != -1) {
335 BT_ERR("This is resevered UUID for easy set up application i = %d \
336 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
337 return OAL_STATUS_ALREADY_DONE;
342 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
344 if (ret != BT_STATUS_SUCCESS) {
345 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
346 return convert_to_oal_status(ret);
348 return OAL_STATUS_SUCCESS;
351 oal_status_t gatts_unregister(int instance_id)
353 int ret = OAL_STATUS_SUCCESS;
354 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
356 CHECK_OAL_GATT_ENABLED();
357 CHECK_SERVER_INSTANCE(instance_id);
358 CHECK_SERVER_REGISTRATION(instance_id);
360 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
362 if (ret != BT_STATUS_SUCCESS) {
363 BT_ERR("GATT server unregistration failed: %d", instance_id);
364 return convert_to_oal_status(ret);
367 gatt_servers[instance_id-1].server_id = -1;
368 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
370 if (instance_id != 1 && instance_id != 2)
371 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
373 return OAL_STATUS_SUCCESS;
376 /* Legacy Advertisement */
377 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
379 int ret = OAL_STATUS_SUCCESS;
380 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
382 CHECK_OAL_GATT_ENABLED();
383 CHECK_SERVER_INSTANCE(instance_id);
384 CHECK_SERVER_REGISTRATION(instance_id);
386 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
388 if (ret != BT_STATUS_SUCCESS) {
389 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
390 gatt_servers[instance_id-1].server_id, status2string(ret));
391 return convert_to_oal_status(ret);
394 return OAL_STATUS_SUCCESS;
397 oal_status_t gatts_stop_advertising(int instance_id)
399 int ret = OAL_STATUS_SUCCESS;
400 API_TRACE("Stop advertising");
402 CHECK_OAL_GATT_ENABLED();
403 CHECK_SERVER_INSTANCE(instance_id);
404 CHECK_SERVER_REGISTRATION(instance_id);
406 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
408 if (ret != BT_STATUS_SUCCESS) {
409 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
410 instance_id, status2string(ret));
411 return convert_to_oal_status(ret);
413 return OAL_STATUS_SUCCESS;
417 /* Below API's need to be removed as they are hardcoded API's.
418 If at all, product specific API's are required to set specific data, then new naming should
419 be adopted for these API's */
420 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
422 int ret = OAL_STATUS_SUCCESS;
424 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
425 CHECK_OAL_GATT_ENABLED();
426 CHECK_SERVER_INSTANCE(instance_id);
427 CHECK_SERVER_REGISTRATION(instance_id);
429 /* Historically used for Legacy Advertising */
430 return OAL_STATUS_NOT_SUPPORT;
433 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
435 int ret = OAL_STATUS_SUCCESS;
437 API_TRACE("Set advertising data");
438 CHECK_OAL_GATT_ENABLED();
439 CHECK_SERVER_INSTANCE(instance_id);
440 CHECK_SERVER_REGISTRATION(instance_id);
442 /* Historically used for Legacy Advertising */
443 return OAL_STATUS_NOT_SUPPORT;
446 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
448 int ret = OAL_STATUS_SUCCESS;
450 API_TRACE("Set Scan Response data");
451 CHECK_OAL_GATT_ENABLED();
452 CHECK_SERVER_INSTANCE(instance_id);
453 CHECK_SERVER_REGISTRATION(instance_id);
455 /* Historically used for Legacy Advertising */
456 return OAL_STATUS_NOT_SUPPORT;
460 oal_status_t gatts_multi_adv_enable(int instance_id)
462 int ret = OAL_STATUS_SUCCESS;
463 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
464 gatt_servers[instance_id - 1].server_id, instance_id);
466 CHECK_OAL_GATT_ENABLED();
467 CHECK_SERVER_INSTANCE(instance_id);
468 CHECK_SERVER_REGISTRATION(instance_id);
470 if (gatt_api->server->multi_adv_enable == NULL)
471 return OAL_STATUS_NOT_SUPPORT;
473 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
474 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
475 BT_ERR("Not allowed, state: %d, instance_id: %d",
476 gatt_servers[instance_id - 1].state, instance_id);
477 return OAL_STATUS_BUSY;
480 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
481 BT_ERR("Not allowed, state: %d, instance_id: %d",
482 gatt_servers[instance_id - 1].state, instance_id);
483 return OAL_STATUS_ALREADY_DONE;
486 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
487 BT_ERR("Not allowed, state: %d, instance_id: %d",
488 gatt_servers[instance_id - 1].state, instance_id);
489 return OAL_STATUS_BUSY;
492 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
494 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
496 if (ret != BT_STATUS_SUCCESS) {
497 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
498 instance_id, status2string(ret));
499 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
500 return convert_to_oal_status(ret);
502 return OAL_STATUS_SUCCESS;
505 oal_status_t gatts_multi_adv_disable(int instance_id)
507 int ret = OAL_STATUS_SUCCESS;
508 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
509 gatt_servers[instance_id - 1].server_id, instance_id);
511 CHECK_OAL_GATT_ENABLED();
512 CHECK_SERVER_INSTANCE(instance_id);
513 CHECK_SERVER_REGISTRATION(instance_id);
515 if (gatt_api->server->multi_adv_disable == NULL)
516 return OAL_STATUS_NOT_SUPPORT;
518 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
519 BT_ERR("Not Allowed, state: %d, instance_id: %d",
520 gatt_servers[instance_id - 1].state, instance_id);
521 return OAL_STATUS_BUSY;
524 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
526 if (ret != BT_STATUS_SUCCESS) {
527 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
528 instance_id, status2string(ret));
529 return convert_to_oal_status(ret);
531 return OAL_STATUS_SUCCESS;
534 oal_status_t gatts_set_filter_policy(int filter_policy)
536 int ret = OAL_STATUS_SUCCESS;
538 CHECK_OAL_GATT_ENABLED();
540 /* send the filter_policy value to the HAL Layer */
541 ret = gatt_api->server->set_filter_policy(filter_policy);
543 if (ret != BT_STATUS_SUCCESS) {
544 BT_ERR("set_filter_policy failed: %d",ret);
545 return convert_to_oal_status(ret);
548 return OAL_STATUS_SUCCESS;
551 oal_status_t gatts_multi_adv_update(int instance_id,
552 int min_intv, int max_intv,
553 int adv_type, int chnl_map,
554 int tx_power, int timeout_s)
556 int ret = OAL_STATUS_SUCCESS;
557 API_TRACE("Multi advertising Update");
559 CHECK_OAL_GATT_ENABLED();
560 CHECK_SERVER_INSTANCE(instance_id);
561 CHECK_SERVER_REGISTRATION(instance_id);
563 if (gatt_api->server->multi_adv_update == NULL)
564 return OAL_STATUS_NOT_SUPPORT;
566 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
569 tx_power, timeout_s);
571 if (ret != BT_STATUS_SUCCESS) {
572 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
573 instance_id, status2string(ret));
574 return convert_to_oal_status(ret);
576 return OAL_STATUS_SUCCESS;
579 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
580 oal_ble_multi_adv_param_setup_t *adv_param_setup)
582 int ret = OAL_STATUS_SUCCESS;
583 btgatt_adv_param_setup_t adv_setup;
584 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
585 gatt_servers[instance_id - 1].server_id, instance_id);
587 CHECK_OAL_GATT_ENABLED();
588 CHECK_SERVER_INSTANCE(instance_id);
589 CHECK_SERVER_REGISTRATION(instance_id);
591 if (gatt_api->server->multi_adv_set_inst_data == NULL)
592 return OAL_STATUS_NOT_SUPPORT;
594 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
595 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
596 return OAL_STATUS_BUSY;
599 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
602 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
603 adv_setup.include_name = adv_param_setup->include_name;
604 adv_setup.include_txpower = adv_param_setup->include_txpower;
605 adv_setup.appearance = adv_param_setup->appearance;
606 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
607 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
608 adv_setup.service_data = adv_param_setup->service_data;
609 adv_setup.service_data_len = adv_param_setup->service_data_len;
610 adv_setup.service_uuid = adv_param_setup->service_uuid;
611 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
612 /* Solicit UUID handler: Start */
613 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
614 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
615 /* Solicit UUID handler: End */
616 adv_setup.min_interval = adv_param_setup->min_interval;
617 adv_setup.max_interval = adv_param_setup->min_interval;
618 adv_setup.adv_type = adv_param_setup->adv_type;
619 adv_setup.chnl_map = adv_param_setup->chnl_map;
620 adv_setup.tx_power = adv_param_setup->tx_power;
621 adv_setup.timeout_s = adv_param_setup->timeout_s;
623 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
625 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
626 if (ret != BT_STATUS_SUCCESS) {
627 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
628 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
629 return convert_to_oal_status(ret);
631 return OAL_STATUS_SUCCESS;
634 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
636 int ret = OAL_STATUS_SUCCESS;
639 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
641 CHECK_OAL_GATT_ENABLED();
642 CHECK_SERVER_INSTANCE(instance_id);
643 CHECK_SERVER_REGISTRATION(instance_id);
645 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
647 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
648 if (ret != BT_STATUS_SUCCESS) {
649 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
650 return convert_to_oal_status(ret);
652 return OAL_STATUS_SUCCESS;
656 /************************************GATT Server Functions*************************************/
658 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
661 char str[2*BT_UUID_STRING_MAX];
662 uuid_to_stringname((service_uuid_t*)uuid, str);
664 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
666 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
667 BT_INFO("UUID: [%s]", str);
669 for (i = 0; i < NUM_SERVER_INST; i++) {
670 if (gatt_servers[i].server_id == -1) {
671 BT_INFO("Server Instance registered with stack [%d]", i+1);
672 gatt_servers[i].server_id = server_if;
673 event->server_inst = i+1;
674 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
675 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
679 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
682 static void cb_gatts_listen(int status, int server_if)
684 gboolean prev_state[NUM_SERVER_INST];
686 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
689 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
690 if (gatt_servers[instance_id - 1].server_id == server_if) {
691 event->server_inst = instance_id;
694 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
697 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
698 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
699 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
700 cur_adv_state[event->server_inst - 1] = new_state;
702 BT_ERR("Invalid Callback...");
707 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
709 if (TRUE == new_state)
710 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
712 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
715 static void cb_gatts_multi_adv_enable(int server_if, int status)
718 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
719 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
722 if (status != BT_STATUS_SUCCESS)
723 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
725 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
726 if (gatt_servers[instance_id - 1].server_id == server_if) {
727 event->server_inst = instance_id;
728 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
732 BT_ERR("Invalid Interface, srv_if: %d", server_if);
733 event->server_inst = -1;
735 event->status = convert_to_oal_status(status);
736 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
739 static void cb_gatts_multi_adv_disable(int server_if, int status)
741 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
742 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
745 if (status != BT_STATUS_SUCCESS)
746 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
748 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
749 if (gatt_servers[instance_id - 1].server_id == server_if) {
750 event->server_inst = instance_id;
751 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
755 BT_ERR("Invalid Interface, srv_if: %d", server_if);
756 event->server_inst = -1;
758 event->status = convert_to_oal_status(status);
759 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
762 static void cb_gatts_multi_adv_update(int server_if, int status)
764 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
765 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
768 if (status != BT_STATUS_SUCCESS)
769 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
771 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
772 if (gatt_servers[instance_id - 1].server_id == server_if) {
773 event->server_inst = instance_id;
777 BT_ERR("Invalid Interface, srv_if: %d", server_if);
778 event->server_inst = -1;
780 event->status = convert_to_oal_status(status);
781 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
784 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
786 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
787 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
790 if (status != BT_STATUS_SUCCESS)
791 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
793 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
794 if (gatt_servers[instance_id - 1].server_id == server_if) {
795 event->server_inst = instance_id;
796 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
800 BT_ERR("Invalid Interface, srv_if: %d", server_if);
801 event->server_inst = -1;
803 event->status = convert_to_oal_status(status);
804 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
807 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
809 int ret = OAL_STATUS_SUCCESS;
810 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
811 CHECK_OAL_GATT_ENABLED();
812 OAL_CHECK_PARAMETER(mtu, return);
814 /* To prevent crash in case other libraries not support this api */
815 if (gatt_api->server->get_att_mtu == NULL) {
816 BT_WARN("get_att_mtu is NULL");
817 return OAL_STATUS_NOT_SUPPORT;
820 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
821 if (ret != BT_STATUS_SUCCESS) {
822 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
823 return convert_to_oal_status(ret);
826 BT_INFO("Current ATT MTU Size: %d", *mtu);
827 return OAL_STATUS_SUCCESS;
829 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
830 int status, int fd, int mtu , void * fdlist)
832 int ret = OAL_STATUS_SUCCESS;
834 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
835 CHECK_OAL_GATT_ENABLED();
837 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
838 if (ret != BT_STATUS_SUCCESS) {
839 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
840 return convert_to_oal_status(ret);
842 return OAL_STATUS_SUCCESS;
845 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
848 int ret = OAL_STATUS_SUCCESS;
849 btgatt_srvc_id_t btgatt_srvc_id;
850 char str[2*BT_UUID_STRING_MAX];
852 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
853 CHECK_OAL_GATT_ENABLED();
855 CHECK_SERVER_INSTANCE(instance_id);
856 CHECK_SERVER_REGISTRATION(instance_id);
858 if (gatt_serv_id != NULL) {
859 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
860 API_TRACE("Service uuid: [%s]", str);
861 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
862 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
863 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
865 BT_INFO("GATT Server Service Id is NULL");
866 return OAL_STATUS_INVALID_PARAM;
869 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
871 if (ret != BT_STATUS_SUCCESS) {
872 BT_ERR("GATT Server add service failed: %s", status2string(ret));
873 return convert_to_oal_status(ret);
875 return OAL_STATUS_SUCCESS;
878 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
881 int ret = OAL_STATUS_SUCCESS;
882 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
883 instance_id, serv_handle, incl_handle);
884 CHECK_OAL_GATT_ENABLED();
886 CHECK_SERVER_INSTANCE(instance_id);
888 CHECK_SERVER_REGISTRATION(instance_id);
890 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
891 if (ret != BT_STATUS_SUCCESS) {
892 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
893 return convert_to_oal_status(ret);
895 return OAL_STATUS_SUCCESS;
898 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
899 oal_uuid_t* charc_uuid, int propts, int permsn)
901 int ret = OAL_STATUS_SUCCESS;
902 char str[2*BT_UUID_STRING_MAX];
903 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
904 char_prop_to_string(propts, prop);
905 char_perm_to_string(permsn, perm);
906 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
907 instance_id, serv_handle, prop, perm);
908 CHECK_OAL_GATT_ENABLED();
910 CHECK_SERVER_INSTANCE(instance_id);
912 CHECK_SERVER_REGISTRATION(instance_id);
914 if (charc_uuid != NULL) {
915 uuid_to_stringname(charc_uuid, str);
916 API_TRACE("uuid: [%s]", str);
919 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
920 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
921 if (ret != BT_STATUS_SUCCESS) {
922 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
923 return convert_to_oal_status(ret);
925 return OAL_STATUS_SUCCESS;
928 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
929 oal_uuid_t* desc_uuid, int permsn)
931 int ret = OAL_STATUS_SUCCESS;
932 char str[2*BT_UUID_STRING_MAX];
933 char perm[MAX_PERM_LEN];
934 char_perm_to_string(permsn, perm);
935 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
936 instance_id, serv_handle, perm);
937 CHECK_OAL_GATT_ENABLED();
939 CHECK_SERVER_INSTANCE(instance_id);
941 CHECK_SERVER_REGISTRATION(instance_id);
943 if (desc_uuid != NULL) {
944 uuid_to_stringname(desc_uuid, str);
945 API_TRACE("uuid: [%s]", str);
948 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
949 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
951 if (ret != BT_STATUS_SUCCESS) {
952 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
953 return convert_to_oal_status(ret);
955 return OAL_STATUS_SUCCESS;
958 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
960 int ret = OAL_STATUS_SUCCESS;
962 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
963 instance_id, svc_handle, transport);
964 CHECK_OAL_GATT_ENABLED();
966 CHECK_SERVER_INSTANCE(instance_id);
968 CHECK_SERVER_REGISTRATION(instance_id);
970 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
972 if (ret != BT_STATUS_SUCCESS) {
973 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
974 return convert_to_oal_status(ret);
976 return OAL_STATUS_SUCCESS;
979 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
981 int ret = OAL_STATUS_SUCCESS;
983 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
984 CHECK_OAL_GATT_ENABLED();
986 CHECK_SERVER_INSTANCE(ins_id);
987 CHECK_SERVER_REGISTRATION(ins_id);
989 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
990 if (ret != BT_STATUS_SUCCESS) {
991 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
992 return convert_to_oal_status(ret);
994 return OAL_STATUS_SUCCESS;
997 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
999 int ret = OAL_STATUS_SUCCESS;
1001 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1002 CHECK_OAL_GATT_ENABLED();
1004 CHECK_SERVER_INSTANCE(ins_id);
1006 CHECK_SERVER_REGISTRATION(ins_id);
1008 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
1009 if (ret != BT_STATUS_SUCCESS) {
1010 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1011 return convert_to_oal_status(ret);
1013 return OAL_STATUS_SUCCESS;
1016 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1018 int ret = OAL_STATUS_SUCCESS;
1020 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1021 CHECK_OAL_GATT_ENABLED();
1023 if (response == NULL) {
1024 BT_ERR("GATT Server attribute value is empty");
1025 return OAL_STATUS_INVALID_PARAM;
1028 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1029 if (ret != BT_STATUS_SUCCESS) {
1030 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1031 return convert_to_oal_status(ret);
1033 return OAL_STATUS_SUCCESS;
1036 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1038 int ret = OAL_STATUS_SUCCESS;
1040 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1041 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1042 CHECK_OAL_GATT_ENABLED();
1044 CHECK_SERVER_INSTANCE(ins_id);
1046 CHECK_SERVER_REGISTRATION(ins_id);
1048 if (value == NULL || len == 0) {
1049 BT_ERR("GATT Server attribute value is empty");
1050 return OAL_STATUS_INVALID_PARAM;
1053 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1054 attr_hndl, conn_id, len, confirm, value);
1056 if (ret != BT_STATUS_SUCCESS) {
1057 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1058 return convert_to_oal_status(ret);
1060 return OAL_STATUS_SUCCESS;
1063 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1065 int ret = OAL_STATUS_SUCCESS;
1067 CHECK_OAL_GATT_ENABLED();
1069 CHECK_SERVER_INSTANCE(ins_id);
1071 CHECK_SERVER_REGISTRATION(ins_id);
1073 if (value == NULL || value->len == 0) {
1074 BT_ERR("GATT Server attribute value is empty");
1075 return OAL_STATUS_INVALID_PARAM;
1078 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1079 ins_id, value->handle, value->len);
1081 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1082 (int)value->handle, (int)value->len, (char*)value->value);
1084 if (ret != BT_STATUS_SUCCESS) {
1085 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1086 return convert_to_oal_status(ret);
1088 return OAL_STATUS_SUCCESS;
1091 /* GATT Server Callbacks:Start */
1092 static void cb_gatts_service_added(int status, int server_if,
1093 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1097 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1098 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1100 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1102 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1103 event->gatt_srvc_stat.server_inst = -1;
1105 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1106 if (psrvc_id != NULL) {
1107 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1108 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1109 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1110 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1113 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1115 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1118 static void cb_gatts_included_service_added(int status, int server_if,
1120 int incl_srvc_handle)
1123 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1124 status, srvc_handle, incl_srvc_handle);
1126 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1128 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1130 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1131 event->gatt_srvc_stat.server_inst = -1;
1133 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1134 event->incl_srvc_hndl = incl_srvc_handle;
1135 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1136 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1139 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1140 int srvc_handle, int char_handle)
1144 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1145 status, srvc_handle, char_handle);
1147 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1149 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1151 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1152 event->gatt_srvc_stat.server_inst = -1;
1154 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1155 event->charctr_hndl = char_handle;
1156 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1157 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1158 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1161 static void cb_gatts_descriptor_added(int status, int server_if,
1162 bt_uuid_t *descr_id, int srvc_handle,
1166 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1167 status, srvc_handle, descr_handle);
1169 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1171 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1173 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1174 event->gatt_srvc_stat.server_inst = -1;
1176 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1177 event->descrptr_hndl = descr_handle;
1178 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1179 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1180 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1183 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1186 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1188 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1190 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1192 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1193 event->server_inst = -1;
1195 event->servic_hndl = srvc_handle;
1196 event->status = convert_to_oal_status(status);
1197 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1200 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1203 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1205 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1207 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1209 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1210 event->server_inst = -1;
1212 event->servic_hndl = srvc_handle;
1213 event->status = convert_to_oal_status(status);
1214 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1217 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1220 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1222 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1224 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1226 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1227 event->server_inst = -1;
1229 event->servic_hndl = srvc_handle;
1230 event->status = convert_to_oal_status(status);
1231 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1234 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1237 oal_event_t event_type;
1239 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1240 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1242 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1243 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1244 event->server_inst = ins_id;
1247 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1250 if (ins_id == NUM_SERVER_INST+1) {
1251 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1255 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1256 event->conn_id = conn_id;
1257 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1258 event->status = OAL_STATUS_SUCCESS;
1260 send_event(event_type, event, sizeof(event_gatts_conn_t));
1263 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1264 int attr_handle, int offset, bool is_long)
1266 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1268 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1270 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1272 event->attr_trans.attr_handle = attr_handle;
1273 event->attr_trans.conn_id = conn_id;
1274 event->attr_trans.trans_id = trans_id;
1275 event->attr_trans.offset = offset;
1276 event->is_long = is_long;
1278 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1281 static void cb_gatts_request_write(int conn_id, int trans_id,
1282 bt_bdaddr_t *bda, int attr_handle,
1283 int offset, int length,
1284 bool need_rsp, bool is_prep, uint8_t* value)
1286 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1288 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1290 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1292 event->attr_trans.attr_handle = attr_handle;
1293 event->attr_trans.conn_id = conn_id;
1294 event->attr_trans.trans_id = trans_id;
1295 event->attr_trans.offset = offset;
1296 event->need_rsp = need_rsp;
1297 event->is_prep = is_prep;
1299 if (length > 0 && value != NULL) {
1300 if (length > OAL_GATT_MAX_ATTR_LEN)
1301 length = OAL_GATT_MAX_ATTR_LEN;
1302 memcpy(event->value, value, length);
1303 event->length = length;
1305 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1308 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1311 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1313 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1315 event->attr_trans.attr_handle = attr_handle;
1316 event->attr_trans.conn_id = conn_id;
1317 event->attr_trans.trans_id = trans_id;
1319 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1321 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1324 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1326 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1328 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1330 event->attr_trans.attr_handle = attr_handle;
1331 event->attr_trans.conn_id = conn_id;
1332 event->attr_trans.trans_id = trans_id;
1335 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1339 static void cb_gatts_response_confirmation(int status, int handle)
1341 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1343 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1345 event->hndl = handle;
1346 event->status = convert_to_oal_status(status);
1348 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1351 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1353 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1354 conn_id, trans_id, attr_handle);
1356 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1358 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1360 event->attr_handle = attr_handle;
1361 event->conn_id = conn_id;
1362 event->trans_id = trans_id;
1363 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1366 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1368 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1369 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1370 event->conn_id = conn_id;
1371 event->mtu_size = mtu;
1372 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1376 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1378 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1379 conn_id, trans_id, attr_handle, notify);
1381 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1383 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1385 event->attr_handle = attr_handle;
1386 event->conn_id = conn_id;
1387 event->trans_id = trans_id;
1388 event->notify = notify;
1389 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1394 /* GATT Server Callbacks: End */
1395 /************************************ GATT Client ***********************************/
1396 /* Client Callbacks */
1397 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1399 char uuid_str[BT_UUID_STRING_MAX];
1400 event_gattc_register_t *event;
1402 /* Check if GATT client registered for Default GATT client UUID */
1403 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1405 BT_INFO("GATT CLIENT REGISTER APP CB, status:%d, clientIf:%d, %s", status, clientIf, uuid_str);
1406 event = g_new0(event_gattc_register_t, 1);
1407 event->client_if = clientIf;
1408 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1409 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1410 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1413 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, uint8_t addr_type, int rssi,
1414 uint8_t *adv_data, int adv_data_len, uint8_t *scan_rsp_data, int scan_rsp_data_len)
1416 event_ble_scan_result_info *event;
1418 event = g_new0(event_ble_scan_result_info, 1);
1419 event->addr_type = addr_type;
1421 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1422 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1423 event->adv_data_len = adv_data_len;
1424 memcpy(event->scan_rsp_data, scan_rsp_data, BLE_ADV_DATA_LENGTH);
1425 event->scan_rsp_data_len = scan_rsp_data_len;
1426 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1427 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1430 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1432 event_gattc_conn_t *event;
1433 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1434 status, client_if, conn_id);
1436 event = g_new0(event_gattc_conn_t, 1);
1437 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1438 event->client_if = client_if;
1440 if (BT_STATUS_SUCCESS != status) {
1441 event->status = OAL_STATUS_INTERNAL_ERROR;
1442 BT_ERR("gattc connection Error: %d", status);
1444 event->conn_id = conn_id;
1445 event->status = OAL_STATUS_SUCCESS;
1448 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1449 sizeof(*event), (bt_address_t *)bda);
1453 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1455 event_gattc_conn_t *event;
1456 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1457 status, client_if, conn_id);
1458 event = g_new0(event_gattc_conn_t, 1);
1459 event->status = convert_to_oal_status(status);
1460 event->client_if = client_if;
1461 event->conn_id = conn_id;
1462 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1463 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1464 sizeof(*event), (bt_address_t *)bda);
1467 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1469 char uuid_str[2*BT_UUID_STRING_MAX];
1471 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1473 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1474 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1475 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1477 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1478 event->conn_status.status = OAL_STATUS_SUCCESS;
1479 event->conn_status.conn_id = conn_id;
1480 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1482 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1485 static void cb_gattc_search_complete(int conn_id, int status)
1487 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1490 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1491 event->conn_id = conn_id;
1492 event->status = convert_to_oal_status(status);
1494 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1498 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1499 btgatt_gatt_id_t *char_id, int char_prop)
1501 char uuid_str1[2*BT_UUID_STRING_MAX];
1502 char uuid_str2[2*BT_UUID_STRING_MAX];
1505 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1506 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1507 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1508 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1510 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1511 event->conn_status.conn_id = conn_id;
1512 event->conn_status.status = convert_to_oal_status(status);
1513 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1516 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1517 BT_INFO("Charac => [%s], Inst_id [%u], Prop [%s]",
1518 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1519 event->char_prop = char_prop;
1520 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1522 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1527 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)
1529 char uuid_str1[2*BT_UUID_STRING_MAX];
1530 char uuid_str2[2*BT_UUID_STRING_MAX];
1531 char uuid_str3[2*BT_UUID_STRING_MAX];
1532 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1533 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1534 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1535 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1536 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1537 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1539 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1540 event->conn_status.conn_id = conn_id;
1541 event->conn_status.status = convert_to_oal_status(status);
1542 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1543 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1546 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1547 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, descr_id->inst_id);
1548 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1550 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1553 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)
1555 char uuid_str1[2*BT_UUID_STRING_MAX];
1556 char uuid_str2[2*BT_UUID_STRING_MAX];
1557 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1558 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1559 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1560 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1561 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1562 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1564 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1565 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1566 event->client_if = client_if;
1567 event->status = convert_to_oal_status(status);
1568 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1569 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1571 send_event(event_type, event, sizeof(*event));
1574 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1577 char uuid_str1[2*BT_UUID_STRING_MAX];
1578 char uuid_str2[2*BT_UUID_STRING_MAX];
1580 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1581 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1582 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1584 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1585 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1587 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1588 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1589 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1591 if (p_data->len > 0) {
1593 data = g_malloc(3*p_data->len+1);
1595 BT_ERR("memory allocation failed");
1599 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1600 BT_INFO("Notified Data: [%s]", data);
1602 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1603 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1604 event->is_notify = p_data->is_notify;
1605 event->data_len = p_data->len;
1606 memcpy(event->data, p_data->value, event->data_len);
1607 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1608 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1610 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1615 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id)
1617 event_gattc_service_changed_data *event = g_new0(event_gattc_service_changed_data, 1);
1619 memcpy(event->address.addr, bd_addr->address, 6);
1620 event->change_type = change_type;
1621 memcpy(event->uuid.uuid, uuid, sizeof(event->uuid.uuid));
1622 event->conn_id = conn_id;
1623 event->inst_id = inst_id;
1625 send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
1628 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1630 char uuid_str1[2*BT_UUID_STRING_MAX];
1631 char uuid_str2[2*BT_UUID_STRING_MAX];
1632 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1634 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1635 event->uuid_status.conn_status.conn_id = conn_id;
1636 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1637 event->value_type = p_data->value_type;
1638 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1639 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1641 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1642 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1643 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1644 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1645 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1646 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1647 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1649 data = g_malloc(3*p_data->value.len+1);
1651 BT_ERR("memory allocation failed");
1655 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1656 BT_DBG("Read Data: [%s]", data);
1657 event->data_len = p_data->value.len;
1658 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1662 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1665 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1667 char uuid_str1[2*BT_UUID_STRING_MAX];
1668 char uuid_str2[2*BT_UUID_STRING_MAX];
1669 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1671 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1672 event->conn_status.conn_id = conn_id;
1673 event->conn_status.status = convert_to_oal_status(status);
1674 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1675 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1677 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1678 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1679 BT_INFO("Service=> [%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 => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1683 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1686 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1688 char uuid_str1[2*BT_UUID_STRING_MAX];
1689 char uuid_str2[2*BT_UUID_STRING_MAX];
1690 char uuid_str3[2*BT_UUID_STRING_MAX];
1691 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1693 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1694 event->conn_status.conn_id = conn_id;
1695 event->conn_status.status = convert_to_oal_status(status);
1696 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1697 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1698 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1700 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1701 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1702 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1703 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1704 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1705 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1706 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1708 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1713 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1715 char uuid_str1[2*BT_UUID_STRING_MAX];
1716 char uuid_str2[2*BT_UUID_STRING_MAX];
1717 char uuid_str3[2*BT_UUID_STRING_MAX];
1718 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1720 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1721 event->uuid_status.conn_status.conn_id = conn_id;
1722 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1723 event->value_type = p_data->value_type;
1724 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1725 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1726 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1729 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1730 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1731 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1732 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1733 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1734 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1735 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1736 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1737 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1739 data = g_malloc(3*p_data->value.len+1);
1741 BT_ERR("memory allocation failed");
1745 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1746 BT_DBG("Read Data: [%s]", data);
1747 event->data_len = p_data->value.len;
1748 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1752 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1755 oal_status_t gattc_start_le_discovery(int client_id)
1758 int ret = OAL_STATUS_SUCCESS;
1760 API_TRACE("BTGATT CLIENT SCAN START");
1761 CHECK_OAL_GATT_ENABLED();
1762 CHECK_CLIENT_REGISTRATION(client_id);
1764 ret = gatt_api->client->scan(client_id, 1);
1765 if (ret != BT_STATUS_SUCCESS) {
1766 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1767 return convert_to_oal_status(ret);
1769 return OAL_STATUS_SUCCESS;
1772 oal_status_t gattc_stop_le_discovery(int client_id)
1775 int ret = OAL_STATUS_SUCCESS;
1777 API_TRACE("Scan is stopped");
1778 CHECK_OAL_GATT_ENABLED();
1779 CHECK_CLIENT_REGISTRATION(client_id);
1780 ret = gatt_api->client->scan(client_id, 0);
1781 if (ret != BT_STATUS_SUCCESS) {
1782 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1783 return convert_to_oal_status(ret);
1785 return OAL_STATUS_SUCCESS;
1788 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1792 API_TRACE("Scan is stopped");
1793 CHECK_OAL_GATT_ENABLED();
1796 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1797 if (ret != BT_STATUS_SUCCESS) {
1798 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1799 return convert_to_oal_status(ret);
1802 ret = gatt_api->client->set_scan_parameters(itv, win);
1803 if (ret != BT_STATUS_SUCCESS) {
1804 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1805 return convert_to_oal_status(ret);
1809 return OAL_STATUS_SUCCESS;
1812 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1814 event_gattc_mtu_configured_t *event;
1815 BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1816 conn_id, status, mtu);
1817 event = g_new0(event_gattc_mtu_configured_t, 1);
1818 event->conn_id = conn_id;
1820 event->status = convert_to_oal_status(status);
1821 send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1824 /************************************ GATT Client ***********************************/
1825 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1828 char str[2*BT_UUID_STRING_MAX];
1829 int ret = OAL_STATUS_SUCCESS;
1831 CHECK_OAL_GATT_ENABLED();
1832 uuid_to_stringname(client_uuid, str);
1833 API_TRACE("uuid: [%s]", str);
1834 /* We will perform actual registration in cb_gattc_register_app callback */
1835 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1836 if (ret != BT_STATUS_SUCCESS) {
1837 BT_ERR("GATT client register failed: %s", status2string(ret));
1838 return convert_to_oal_status(ret);
1840 return OAL_STATUS_SUCCESS;
1843 oal_status_t gattc_deregister(int client_id)
1845 int ret = OAL_STATUS_SUCCESS;
1847 API_TRACE("GATT client deregister");
1848 CHECK_OAL_GATT_ENABLED();
1849 CHECK_CLIENT_REGISTRATION(client_id);
1851 ret = gatt_api->client->unregister_client(client_id);
1852 if (ret != BT_STATUS_SUCCESS) {
1853 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1854 return convert_to_oal_status(ret);
1857 return OAL_STATUS_SUCCESS;
1860 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1862 int ret = OAL_STATUS_SUCCESS;
1865 OAL_CHECK_PARAMETER(device_address, return);
1866 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1867 CHECK_OAL_GATT_ENABLED();
1868 CHECK_CLIENT_REGISTRATION(client_id);
1870 /* Handle the actual connection in cb_gattc_connection callback */
1871 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1872 if (ret != BT_STATUS_SUCCESS) {
1873 BT_ERR("GATT client connect failed: %s", status2string(ret));
1874 return convert_to_oal_status(ret);
1876 return OAL_STATUS_SUCCESS;
1879 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1882 int ret = OAL_STATUS_SUCCESS;
1885 OAL_CHECK_PARAMETER(device_address, return);
1886 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1887 CHECK_OAL_GATT_ENABLED();
1888 CHECK_CLIENT_REGISTRATION(client_id);
1889 CHECK_CLIENT_CONNECTION(conn_id);
1891 /* Handle actual disconnection in callback */
1892 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1893 if (ret != BT_STATUS_SUCCESS) {
1894 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1895 return convert_to_oal_status(ret);
1897 return OAL_STATUS_SUCCESS;
1901 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1903 int ret = OAL_STATUS_SUCCESS;
1904 char uuid_str[2*BT_UUID_STRING_MAX];
1907 uuid_to_stringname(service_uuid, uuid_str);
1908 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1910 API_TRACE("Client Service Search All");
1912 CHECK_OAL_GATT_ENABLED();
1913 CHECK_CLIENT_CONNECTION(conn_id);
1914 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1916 if (ret != BT_STATUS_SUCCESS) {
1917 BT_ERR("GATT client service search failed: %s", status2string(ret));
1918 return convert_to_oal_status(ret);
1920 return OAL_STATUS_SUCCESS;
1923 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1925 int ret = OAL_STATUS_SUCCESS;
1926 char uuid_str[2*BT_UUID_STRING_MAX];
1928 OAL_CHECK_PARAMETER(srvc_id, return);
1929 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1930 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1931 CHECK_OAL_GATT_ENABLED();
1932 CHECK_CLIENT_CONNECTION(conn_id);
1933 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1934 (btgatt_gatt_id_t *)char_id);
1935 if (ret != BT_STATUS_SUCCESS) {
1936 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1937 return convert_to_oal_status(ret);
1939 return OAL_STATUS_SUCCESS;
1942 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1943 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1945 int ret = OAL_STATUS_SUCCESS;
1946 char uuid_str1[2*BT_UUID_STRING_MAX];
1947 char uuid_str2[2*BT_UUID_STRING_MAX];
1949 OAL_CHECK_PARAMETER(srvc_id, return);
1950 OAL_CHECK_PARAMETER(char_id, return);
1951 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1952 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1953 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1954 CHECK_OAL_GATT_ENABLED();
1955 CHECK_CLIENT_CONNECTION(conn_id);
1956 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1957 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1958 if (ret != BT_STATUS_SUCCESS) {
1959 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1960 return convert_to_oal_status(ret);
1962 return OAL_STATUS_SUCCESS;
1965 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1966 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1967 int ret = OAL_STATUS_SUCCESS;
1968 char uuid_str1[2*BT_UUID_STRING_MAX];
1969 char uuid_str2[2*BT_UUID_STRING_MAX];
1972 OAL_CHECK_PARAMETER(address, return);
1973 OAL_CHECK_PARAMETER(srvc_id, return);
1974 OAL_CHECK_PARAMETER(char_id, return);
1975 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1976 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1977 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1978 CHECK_OAL_GATT_ENABLED();
1979 CHECK_CLIENT_REGISTRATION(client_id);
1981 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);
1982 if (ret != BT_STATUS_SUCCESS) {
1983 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1984 return convert_to_oal_status(ret);
1987 return OAL_STATUS_SUCCESS;
1990 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1991 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1992 int ret = OAL_STATUS_SUCCESS;
1993 char uuid_str1[2*BT_UUID_STRING_MAX];
1994 char uuid_str2[2*BT_UUID_STRING_MAX];
1997 OAL_CHECK_PARAMETER(address, return);
1998 OAL_CHECK_PARAMETER(srvc_id, return);
1999 OAL_CHECK_PARAMETER(char_id, return);
2000 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2001 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2002 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
2003 CHECK_OAL_GATT_ENABLED();
2004 CHECK_CLIENT_REGISTRATION(client_id);
2006 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);
2007 if (ret != BT_STATUS_SUCCESS) {
2008 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2009 return convert_to_oal_status(ret);
2012 return OAL_STATUS_SUCCESS;
2016 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2017 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2019 int ret = OAL_STATUS_SUCCESS;
2020 char uuid_str1[2*BT_UUID_STRING_MAX];
2021 char uuid_str2[2*BT_UUID_STRING_MAX];
2023 OAL_CHECK_PARAMETER(srvc_id, return);
2024 OAL_CHECK_PARAMETER(char_id, return);
2025 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2026 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2027 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2028 CHECK_OAL_GATT_ENABLED();
2029 CHECK_CLIENT_CONNECTION(conn_id);
2031 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2032 (btgatt_gatt_id_t *)char_id, auth_req);
2033 if (ret != BT_STATUS_SUCCESS) {
2034 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2035 return convert_to_oal_status(ret);
2038 return OAL_STATUS_SUCCESS;
2041 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2042 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2044 int ret = OAL_STATUS_SUCCESS;
2045 char uuid_str1[2*BT_UUID_STRING_MAX];
2046 char uuid_str2[2*BT_UUID_STRING_MAX];
2047 char uuid_str3[2*BT_UUID_STRING_MAX];
2049 OAL_CHECK_PARAMETER(srvc_id, return);
2050 OAL_CHECK_PARAMETER(char_id, return);
2051 OAL_CHECK_PARAMETER(desc_id, return);
2052 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2053 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2054 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2055 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2056 uuid_str1, uuid_str2, uuid_str3);
2057 CHECK_OAL_GATT_ENABLED();
2058 CHECK_CLIENT_CONNECTION(conn_id);
2060 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2061 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2062 if (ret != BT_STATUS_SUCCESS) {
2063 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2064 return convert_to_oal_status(ret);
2067 return OAL_STATUS_SUCCESS;
2070 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2071 oal_gatt_id_t *char_id, int *fd, int *mtu)
2073 int ret = OAL_STATUS_SUCCESS;
2074 char uuid_str1[2*BT_UUID_STRING_MAX];
2075 char uuid_str2[2*BT_UUID_STRING_MAX];
2076 OAL_CHECK_PARAMETER(srvc_id, return);
2077 OAL_CHECK_PARAMETER(char_id, return);
2078 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2079 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2080 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2081 CHECK_OAL_GATT_ENABLED();
2082 CHECK_CLIENT_CONNECTION(conn_id);
2084 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2085 (btgatt_gatt_id_t *)char_id, fd, mtu);
2086 if (ret != BT_STATUS_SUCCESS) {
2087 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2088 return convert_to_oal_status(ret);
2091 return OAL_STATUS_SUCCESS;
2094 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2095 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2097 int ret = OAL_STATUS_SUCCESS;
2098 char uuid_str1[2*BT_UUID_STRING_MAX];
2099 char uuid_str2[2*BT_UUID_STRING_MAX];
2100 OAL_CHECK_PARAMETER(srvc_id, return);
2101 OAL_CHECK_PARAMETER(char_id, return);
2102 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2103 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2104 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2105 CHECK_OAL_GATT_ENABLED();
2106 CHECK_CLIENT_CONNECTION(conn_id);
2108 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2109 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2110 if (ret != BT_STATUS_SUCCESS) {
2111 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2112 return convert_to_oal_status(ret);
2115 return OAL_STATUS_SUCCESS;
2118 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2119 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2120 int len, oal_gatt_auth_req_t auth_req, char* data)
2122 int ret = OAL_STATUS_SUCCESS;
2123 char uuid_str1[2*BT_UUID_STRING_MAX];
2124 char uuid_str2[2*BT_UUID_STRING_MAX];
2125 OAL_CHECK_PARAMETER(srvc_id, return);
2126 OAL_CHECK_PARAMETER(char_id, return);
2127 OAL_CHECK_PARAMETER(data, return);
2128 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2129 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2130 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2131 CHECK_OAL_GATT_ENABLED();
2132 CHECK_CLIENT_CONNECTION(conn_id);
2134 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2135 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2136 if (ret != BT_STATUS_SUCCESS) {
2137 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2138 return convert_to_oal_status(ret);
2141 return OAL_STATUS_SUCCESS;
2144 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2145 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2146 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2148 int ret = OAL_STATUS_SUCCESS;
2149 char uuid_str1[2*BT_UUID_STRING_MAX];
2150 char uuid_str2[2*BT_UUID_STRING_MAX];
2151 char uuid_str3[2*BT_UUID_STRING_MAX];
2152 OAL_CHECK_PARAMETER(srvc_id, return);
2153 OAL_CHECK_PARAMETER(char_id, return);
2154 OAL_CHECK_PARAMETER(desc_id, return);
2155 OAL_CHECK_PARAMETER(data, return);
2156 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2157 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2158 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2159 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2160 uuid_str1, uuid_str2, uuid_str3);
2161 CHECK_OAL_GATT_ENABLED();
2162 CHECK_CLIENT_CONNECTION(conn_id);
2164 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2165 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2166 if (ret != BT_STATUS_SUCCESS) {
2167 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2168 return convert_to_oal_status(ret);
2171 return OAL_STATUS_SUCCESS;
2174 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2179 OAL_CHECK_PARAMETER(address, return);
2180 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2181 CHECK_OAL_GATT_ENABLED();
2183 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2184 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2185 if (ret != BT_STATUS_SUCCESS) {
2186 BT_ERR("error: %s", status2string(ret));
2187 return convert_to_oal_status(ret);
2189 return OAL_STATUS_SUCCESS;
2192 oal_status_t gattc_unregister_scan_filter(int slot_id)
2198 CHECK_OAL_GATT_ENABLED();
2200 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2202 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2203 if (ret != BT_STATUS_SUCCESS) {
2204 BT_ERR("error: %s", status2string(ret));
2205 return convert_to_oal_status(ret);
2207 return OAL_STATUS_SUCCESS;
2210 oal_status_t gattc_enable_scan_filter(int client_if)
2215 CHECK_OAL_GATT_ENABLED();
2217 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2219 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2220 if (ret != BT_STATUS_SUCCESS) {
2221 BT_ERR("error: %s", status2string(ret));
2222 return convert_to_oal_status(ret);
2224 return OAL_STATUS_SUCCESS;
2227 oal_status_t gattc_disable_scan_filter(int client_if)
2232 CHECK_OAL_GATT_ENABLED();
2234 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2236 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2237 if (ret != BT_STATUS_SUCCESS) {
2238 BT_ERR("error: %s", status2string(ret));
2239 return convert_to_oal_status(ret);
2241 return OAL_STATUS_SUCCESS;
2244 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2247 int client_info = 0;
2250 int company_id_mask = 0;
2251 int address_type = 0;
2252 int feature_selection = 0;
2254 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2255 .filt_logic_type = 1,
2256 .rssi_high_thres = -127,
2257 .rssi_low_thres = -127,
2261 .found_timeout_cnt = 0
2264 OAL_CHECK_PARAMETER(filter_data, return);
2266 CHECK_OAL_GATT_ENABLED();
2268 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2270 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2271 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2272 ret = gatt_api->client->scan_filter_add_remove(client_info,
2274 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2275 filter_data->slot_id,
2280 (bt_bdaddr_t*)filter_data->device_address,
2287 if (ret != BT_STATUS_SUCCESS){
2288 BT_ERR("error: %s", status2string(ret));
2289 BT_INFO("unregistering already set filter features.");
2290 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2291 return convert_to_oal_status(ret);
2294 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2296 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2297 ret = gatt_api->client->scan_filter_add_remove(client_info,
2299 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2300 filter_data->slot_id,
2308 filter_data->device_name, // device_name as p_data in HAL
2312 if (ret != BT_STATUS_SUCCESS){
2313 BT_ERR("error: %s", status2string(ret));
2314 BT_INFO("unregistering already set filter features.");
2315 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2316 return convert_to_oal_status(ret);
2319 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2321 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2322 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2323 char uuid_str1[2*BT_UUID_STRING_MAX];
2324 char uuid_str2[2*BT_UUID_STRING_MAX];
2326 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2327 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2329 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2330 ret = gatt_api->client->scan_filter_add_remove(client_info,
2332 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2333 filter_data->slot_id,
2336 (bt_uuid_t*)filter_data->service_uuid,
2337 (bt_uuid_t*)filter_data->service_uuid_mask,
2340 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2342 filter_data->service_uuid_mask_len,
2345 if (ret != BT_STATUS_SUCCESS){
2346 BT_ERR("error: %s", status2string(ret));
2347 BT_INFO("unregistering already set filter features.");
2348 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2349 return convert_to_oal_status(ret);
2352 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2354 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2355 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2356 char uuid_str1[2*BT_UUID_STRING_MAX];
2357 char uuid_str2[2*BT_UUID_STRING_MAX];
2358 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2359 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2360 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2361 ret = gatt_api->client->scan_filter_add_remove(client_info,
2363 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2364 filter_data->slot_id,
2367 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2368 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2371 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2373 filter_data->service_solicitation_uuid_mask_len,
2376 if (ret != BT_STATUS_SUCCESS){
2377 BT_ERR("error: %s", status2string(ret));
2378 BT_INFO("unregistering already set filter features.");
2379 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2380 return convert_to_oal_status(ret);
2383 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2385 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2386 ret = gatt_api->client->scan_filter_add_remove(client_info,
2388 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2389 filter_data->slot_id,
2396 filter_data->service_data_len, //service_data_len as data_len in HAL
2397 (char*)filter_data->service_data,
2398 filter_data->service_data_mask_len,
2399 (char*)filter_data->service_data_mask
2401 if (ret != BT_STATUS_SUCCESS){
2402 BT_ERR("error: %s", status2string(ret));
2403 BT_INFO("unregistering already set filter features.");
2404 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2405 return convert_to_oal_status(ret);
2408 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2410 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2411 ret = gatt_api->client->scan_filter_add_remove(client_info,
2413 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2414 filter_data->slot_id,
2415 filter_data->manufacturer_id,
2421 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2422 (char*)filter_data->manufacturer_data,
2423 filter_data->manufacturer_data_mask_len,
2424 (char*)filter_data->manufacturer_data_mask
2426 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2427 if (ret != BT_STATUS_SUCCESS){
2428 BT_ERR("error: %s", status2string(ret));
2429 BT_INFO("unregistering already set filter features.");
2430 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2431 return convert_to_oal_status(ret);
2434 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2437 BT_DBG("Filter selection 0x%.2x", feature_selection);
2439 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2440 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2441 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2442 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2443 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2444 if (ret != BT_STATUS_SUCCESS){
2445 BT_ERR("error: %s", status2string(ret));
2446 return convert_to_oal_status(ret);
2448 return OAL_STATUS_SUCCESS;
2451 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2455 API_TRACE("Configure MTU Size: [%d]", mtu);
2456 CHECK_OAL_GATT_ENABLED();
2457 CHECK_CLIENT_CONNECTION(conn_id);
2459 /* To prevent crash in case other libraries not support this api */
2460 if (gatt_api->client->configure_mtu == NULL) {
2461 BT_WARN("configure_mtu is NULL");
2462 return OAL_STATUS_NOT_SUPPORT;
2465 ret = gatt_api->client->configure_mtu(conn_id, mtu);
2466 if (ret != BT_STATUS_SUCCESS) {
2467 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2468 return convert_to_oal_status(ret);
2470 return OAL_STATUS_SUCCESS;
2473 oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int server_inst_id)
2475 int ret = OAL_STATUS_SUCCESS;
2478 OAL_CHECK_PARAMETER(device_address, return);
2479 API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
2480 CHECK_OAL_GATT_ENABLED();
2481 CHECK_SERVER_INSTANCE(server_inst_id);
2482 CHECK_SERVER_REGISTRATION(server_inst_id);
2484 ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, server_inst_id);
2485 if (ret != BT_STATUS_SUCCESS) {
2486 BT_ERR("GATT connection info add failed: %s", status2string(ret));
2487 return convert_to_oal_status(ret);
2489 return OAL_STATUS_SUCCESS;