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);
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)
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));
1617 send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
1620 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1622 char uuid_str1[2*BT_UUID_STRING_MAX];
1623 char uuid_str2[2*BT_UUID_STRING_MAX];
1624 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1626 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1627 event->uuid_status.conn_status.conn_id = conn_id;
1628 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1629 event->value_type = p_data->value_type;
1630 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1631 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1633 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1634 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1635 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1636 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1637 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1638 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1639 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1641 data = g_malloc(3*p_data->value.len+1);
1643 BT_ERR("memory allocation failed");
1647 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1648 BT_DBG("Read Data: [%s]", data);
1649 event->data_len = p_data->value.len;
1650 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1654 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1657 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1659 char uuid_str1[2*BT_UUID_STRING_MAX];
1660 char uuid_str2[2*BT_UUID_STRING_MAX];
1661 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1663 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1664 event->conn_status.conn_id = conn_id;
1665 event->conn_status.status = convert_to_oal_status(status);
1666 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1667 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1669 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1670 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1671 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1672 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1673 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1675 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1678 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1680 char uuid_str1[2*BT_UUID_STRING_MAX];
1681 char uuid_str2[2*BT_UUID_STRING_MAX];
1682 char uuid_str3[2*BT_UUID_STRING_MAX];
1683 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1685 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1686 event->conn_status.conn_id = conn_id;
1687 event->conn_status.status = convert_to_oal_status(status);
1688 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1689 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1690 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1692 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1693 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1694 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1695 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1696 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1697 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1698 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1700 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1705 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1707 char uuid_str1[2*BT_UUID_STRING_MAX];
1708 char uuid_str2[2*BT_UUID_STRING_MAX];
1709 char uuid_str3[2*BT_UUID_STRING_MAX];
1710 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1712 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1713 event->uuid_status.conn_status.conn_id = conn_id;
1714 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1715 event->value_type = p_data->value_type;
1716 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1717 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1718 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1721 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1722 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1723 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1724 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1725 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1726 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1727 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1728 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1729 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1731 data = g_malloc(3*p_data->value.len+1);
1733 BT_ERR("memory allocation failed");
1737 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1738 BT_DBG("Read Data: [%s]", data);
1739 event->data_len = p_data->value.len;
1740 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1744 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1747 oal_status_t gattc_start_le_discovery(int client_id)
1750 int ret = OAL_STATUS_SUCCESS;
1752 API_TRACE("BTGATT CLIENT SCAN START");
1753 CHECK_OAL_GATT_ENABLED();
1754 CHECK_CLIENT_REGISTRATION(client_id);
1756 ret = gatt_api->client->scan(client_id, 1);
1757 if (ret != BT_STATUS_SUCCESS) {
1758 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1759 return convert_to_oal_status(ret);
1761 return OAL_STATUS_SUCCESS;
1764 oal_status_t gattc_stop_le_discovery(int client_id)
1767 int ret = OAL_STATUS_SUCCESS;
1769 API_TRACE("Scan is stopped");
1770 CHECK_OAL_GATT_ENABLED();
1771 CHECK_CLIENT_REGISTRATION(client_id);
1772 ret = gatt_api->client->scan(client_id, 0);
1773 if (ret != BT_STATUS_SUCCESS) {
1774 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1775 return convert_to_oal_status(ret);
1777 return OAL_STATUS_SUCCESS;
1780 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1784 API_TRACE("Scan is stopped");
1785 CHECK_OAL_GATT_ENABLED();
1788 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1789 if (ret != BT_STATUS_SUCCESS) {
1790 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1791 return convert_to_oal_status(ret);
1794 ret = gatt_api->client->set_scan_parameters(itv, win);
1795 if (ret != BT_STATUS_SUCCESS) {
1796 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1797 return convert_to_oal_status(ret);
1801 return OAL_STATUS_SUCCESS;
1804 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1806 event_gattc_mtu_configured_t *event;
1807 BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1808 conn_id, status, mtu);
1809 event = g_new0(event_gattc_mtu_configured_t, 1);
1810 event->conn_id = conn_id;
1812 event->status = convert_to_oal_status(status);
1813 send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1816 /************************************ GATT Client ***********************************/
1817 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1820 char str[2*BT_UUID_STRING_MAX];
1821 int ret = OAL_STATUS_SUCCESS;
1823 CHECK_OAL_GATT_ENABLED();
1824 uuid_to_stringname(client_uuid, str);
1825 API_TRACE("uuid: [%s]", str);
1826 /* We will perform actual registration in cb_gattc_register_app callback */
1827 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1828 if (ret != BT_STATUS_SUCCESS) {
1829 BT_ERR("GATT client register failed: %s", status2string(ret));
1830 return convert_to_oal_status(ret);
1832 return OAL_STATUS_SUCCESS;
1835 oal_status_t gattc_deregister(int client_id)
1837 int ret = OAL_STATUS_SUCCESS;
1839 API_TRACE("GATT client deregister");
1840 CHECK_OAL_GATT_ENABLED();
1841 CHECK_CLIENT_REGISTRATION(client_id);
1843 ret = gatt_api->client->unregister_client(client_id);
1844 if (ret != BT_STATUS_SUCCESS) {
1845 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1846 return convert_to_oal_status(ret);
1849 return OAL_STATUS_SUCCESS;
1852 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1854 int ret = OAL_STATUS_SUCCESS;
1857 OAL_CHECK_PARAMETER(device_address, return);
1858 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1859 CHECK_OAL_GATT_ENABLED();
1860 CHECK_CLIENT_REGISTRATION(client_id);
1862 /* Handle the actual connection in cb_gattc_connection callback */
1863 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1864 if (ret != BT_STATUS_SUCCESS) {
1865 BT_ERR("GATT client connect failed: %s", status2string(ret));
1866 return convert_to_oal_status(ret);
1868 return OAL_STATUS_SUCCESS;
1871 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1874 int ret = OAL_STATUS_SUCCESS;
1877 OAL_CHECK_PARAMETER(device_address, return);
1878 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1879 CHECK_OAL_GATT_ENABLED();
1880 CHECK_CLIENT_REGISTRATION(client_id);
1881 CHECK_CLIENT_CONNECTION(conn_id);
1883 /* Handle actual disconnection in callback */
1884 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1885 if (ret != BT_STATUS_SUCCESS) {
1886 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1887 return convert_to_oal_status(ret);
1889 return OAL_STATUS_SUCCESS;
1893 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1895 int ret = OAL_STATUS_SUCCESS;
1896 char uuid_str[2*BT_UUID_STRING_MAX];
1899 uuid_to_stringname(service_uuid, uuid_str);
1900 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1902 API_TRACE("Client Service Search All");
1904 CHECK_OAL_GATT_ENABLED();
1905 CHECK_CLIENT_CONNECTION(conn_id);
1906 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1908 if (ret != BT_STATUS_SUCCESS) {
1909 BT_ERR("GATT client service search failed: %s", status2string(ret));
1910 return convert_to_oal_status(ret);
1912 return OAL_STATUS_SUCCESS;
1915 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1917 int ret = OAL_STATUS_SUCCESS;
1918 char uuid_str[2*BT_UUID_STRING_MAX];
1920 OAL_CHECK_PARAMETER(srvc_id, return);
1921 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1922 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1923 CHECK_OAL_GATT_ENABLED();
1924 CHECK_CLIENT_CONNECTION(conn_id);
1925 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1926 (btgatt_gatt_id_t *)char_id);
1927 if (ret != BT_STATUS_SUCCESS) {
1928 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1929 return convert_to_oal_status(ret);
1931 return OAL_STATUS_SUCCESS;
1934 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1935 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1937 int ret = OAL_STATUS_SUCCESS;
1938 char uuid_str1[2*BT_UUID_STRING_MAX];
1939 char uuid_str2[2*BT_UUID_STRING_MAX];
1941 OAL_CHECK_PARAMETER(srvc_id, return);
1942 OAL_CHECK_PARAMETER(char_id, return);
1943 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1944 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1945 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1946 CHECK_OAL_GATT_ENABLED();
1947 CHECK_CLIENT_CONNECTION(conn_id);
1948 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1949 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1950 if (ret != BT_STATUS_SUCCESS) {
1951 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1952 return convert_to_oal_status(ret);
1954 return OAL_STATUS_SUCCESS;
1957 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1958 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1959 int ret = OAL_STATUS_SUCCESS;
1960 char uuid_str1[2*BT_UUID_STRING_MAX];
1961 char uuid_str2[2*BT_UUID_STRING_MAX];
1964 OAL_CHECK_PARAMETER(address, return);
1965 OAL_CHECK_PARAMETER(srvc_id, return);
1966 OAL_CHECK_PARAMETER(char_id, return);
1967 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1968 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1969 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1970 CHECK_OAL_GATT_ENABLED();
1971 CHECK_CLIENT_REGISTRATION(client_id);
1973 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);
1974 if (ret != BT_STATUS_SUCCESS) {
1975 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1976 return convert_to_oal_status(ret);
1979 return OAL_STATUS_SUCCESS;
1982 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1983 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1984 int ret = OAL_STATUS_SUCCESS;
1985 char uuid_str1[2*BT_UUID_STRING_MAX];
1986 char uuid_str2[2*BT_UUID_STRING_MAX];
1989 OAL_CHECK_PARAMETER(address, return);
1990 OAL_CHECK_PARAMETER(srvc_id, return);
1991 OAL_CHECK_PARAMETER(char_id, return);
1992 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1993 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1994 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1995 CHECK_OAL_GATT_ENABLED();
1996 CHECK_CLIENT_REGISTRATION(client_id);
1998 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);
1999 if (ret != BT_STATUS_SUCCESS) {
2000 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2001 return convert_to_oal_status(ret);
2004 return OAL_STATUS_SUCCESS;
2008 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2009 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2011 int ret = OAL_STATUS_SUCCESS;
2012 char uuid_str1[2*BT_UUID_STRING_MAX];
2013 char uuid_str2[2*BT_UUID_STRING_MAX];
2015 OAL_CHECK_PARAMETER(srvc_id, return);
2016 OAL_CHECK_PARAMETER(char_id, return);
2017 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2018 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2019 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2020 CHECK_OAL_GATT_ENABLED();
2021 CHECK_CLIENT_CONNECTION(conn_id);
2023 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2024 (btgatt_gatt_id_t *)char_id, auth_req);
2025 if (ret != BT_STATUS_SUCCESS) {
2026 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2027 return convert_to_oal_status(ret);
2030 return OAL_STATUS_SUCCESS;
2033 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2034 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2036 int ret = OAL_STATUS_SUCCESS;
2037 char uuid_str1[2*BT_UUID_STRING_MAX];
2038 char uuid_str2[2*BT_UUID_STRING_MAX];
2039 char uuid_str3[2*BT_UUID_STRING_MAX];
2041 OAL_CHECK_PARAMETER(srvc_id, return);
2042 OAL_CHECK_PARAMETER(char_id, return);
2043 OAL_CHECK_PARAMETER(desc_id, return);
2044 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2045 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2046 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2047 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2048 uuid_str1, uuid_str2, uuid_str3);
2049 CHECK_OAL_GATT_ENABLED();
2050 CHECK_CLIENT_CONNECTION(conn_id);
2052 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2053 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2054 if (ret != BT_STATUS_SUCCESS) {
2055 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2056 return convert_to_oal_status(ret);
2059 return OAL_STATUS_SUCCESS;
2062 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2063 oal_gatt_id_t *char_id, int *fd, int *mtu)
2065 int ret = OAL_STATUS_SUCCESS;
2066 char uuid_str1[2*BT_UUID_STRING_MAX];
2067 char uuid_str2[2*BT_UUID_STRING_MAX];
2068 OAL_CHECK_PARAMETER(srvc_id, return);
2069 OAL_CHECK_PARAMETER(char_id, return);
2070 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2071 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2072 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2073 CHECK_OAL_GATT_ENABLED();
2074 CHECK_CLIENT_CONNECTION(conn_id);
2076 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2077 (btgatt_gatt_id_t *)char_id, fd, mtu);
2078 if (ret != BT_STATUS_SUCCESS) {
2079 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2080 return convert_to_oal_status(ret);
2083 return OAL_STATUS_SUCCESS;
2086 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2087 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2089 int ret = OAL_STATUS_SUCCESS;
2090 char uuid_str1[2*BT_UUID_STRING_MAX];
2091 char uuid_str2[2*BT_UUID_STRING_MAX];
2092 OAL_CHECK_PARAMETER(srvc_id, return);
2093 OAL_CHECK_PARAMETER(char_id, return);
2094 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2095 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2096 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2097 CHECK_OAL_GATT_ENABLED();
2098 CHECK_CLIENT_CONNECTION(conn_id);
2100 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2101 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2102 if (ret != BT_STATUS_SUCCESS) {
2103 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2104 return convert_to_oal_status(ret);
2107 return OAL_STATUS_SUCCESS;
2110 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2111 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2112 int len, oal_gatt_auth_req_t auth_req, char* data)
2114 int ret = OAL_STATUS_SUCCESS;
2115 char uuid_str1[2*BT_UUID_STRING_MAX];
2116 char uuid_str2[2*BT_UUID_STRING_MAX];
2117 OAL_CHECK_PARAMETER(srvc_id, return);
2118 OAL_CHECK_PARAMETER(char_id, return);
2119 OAL_CHECK_PARAMETER(data, return);
2120 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2121 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2122 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2123 CHECK_OAL_GATT_ENABLED();
2124 CHECK_CLIENT_CONNECTION(conn_id);
2126 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2127 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2128 if (ret != BT_STATUS_SUCCESS) {
2129 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2130 return convert_to_oal_status(ret);
2133 return OAL_STATUS_SUCCESS;
2136 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2137 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2138 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2140 int ret = OAL_STATUS_SUCCESS;
2141 char uuid_str1[2*BT_UUID_STRING_MAX];
2142 char uuid_str2[2*BT_UUID_STRING_MAX];
2143 char uuid_str3[2*BT_UUID_STRING_MAX];
2144 OAL_CHECK_PARAMETER(srvc_id, return);
2145 OAL_CHECK_PARAMETER(char_id, return);
2146 OAL_CHECK_PARAMETER(desc_id, return);
2147 OAL_CHECK_PARAMETER(data, return);
2148 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2149 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2150 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2151 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2152 uuid_str1, uuid_str2, uuid_str3);
2153 CHECK_OAL_GATT_ENABLED();
2154 CHECK_CLIENT_CONNECTION(conn_id);
2156 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2157 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2158 if (ret != BT_STATUS_SUCCESS) {
2159 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2160 return convert_to_oal_status(ret);
2163 return OAL_STATUS_SUCCESS;
2166 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2171 OAL_CHECK_PARAMETER(address, return);
2172 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2173 CHECK_OAL_GATT_ENABLED();
2175 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2176 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2177 if (ret != BT_STATUS_SUCCESS) {
2178 BT_ERR("error: %s", status2string(ret));
2179 return convert_to_oal_status(ret);
2181 return OAL_STATUS_SUCCESS;
2184 oal_status_t gattc_unregister_scan_filter(int slot_id)
2190 CHECK_OAL_GATT_ENABLED();
2192 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2194 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2195 if (ret != BT_STATUS_SUCCESS) {
2196 BT_ERR("error: %s", status2string(ret));
2197 return convert_to_oal_status(ret);
2199 return OAL_STATUS_SUCCESS;
2202 oal_status_t gattc_enable_scan_filter(int client_if)
2207 CHECK_OAL_GATT_ENABLED();
2209 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2211 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2212 if (ret != BT_STATUS_SUCCESS) {
2213 BT_ERR("error: %s", status2string(ret));
2214 return convert_to_oal_status(ret);
2216 return OAL_STATUS_SUCCESS;
2219 oal_status_t gattc_disable_scan_filter(int client_if)
2224 CHECK_OAL_GATT_ENABLED();
2226 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2228 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2229 if (ret != BT_STATUS_SUCCESS) {
2230 BT_ERR("error: %s", status2string(ret));
2231 return convert_to_oal_status(ret);
2233 return OAL_STATUS_SUCCESS;
2236 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2239 int client_info = 0;
2242 int company_id_mask = 0;
2243 int address_type = 0;
2244 int feature_selection = 0;
2246 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2247 .filt_logic_type = 1,
2248 .rssi_high_thres = -127,
2249 .rssi_low_thres = -127,
2253 .found_timeout_cnt = 0
2256 OAL_CHECK_PARAMETER(filter_data, return);
2258 CHECK_OAL_GATT_ENABLED();
2260 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2262 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2263 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2264 ret = gatt_api->client->scan_filter_add_remove(client_info,
2266 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2267 filter_data->slot_id,
2272 (bt_bdaddr_t*)filter_data->device_address,
2279 if (ret != BT_STATUS_SUCCESS){
2280 BT_ERR("error: %s", status2string(ret));
2281 BT_INFO("unregistering already set filter features.");
2282 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2283 return convert_to_oal_status(ret);
2286 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2288 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2289 ret = gatt_api->client->scan_filter_add_remove(client_info,
2291 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2292 filter_data->slot_id,
2300 filter_data->device_name, // device_name as p_data in HAL
2304 if (ret != BT_STATUS_SUCCESS){
2305 BT_ERR("error: %s", status2string(ret));
2306 BT_INFO("unregistering already set filter features.");
2307 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2308 return convert_to_oal_status(ret);
2311 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2313 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2314 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2315 char uuid_str1[2*BT_UUID_STRING_MAX];
2316 char uuid_str2[2*BT_UUID_STRING_MAX];
2318 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2319 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2321 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2322 ret = gatt_api->client->scan_filter_add_remove(client_info,
2324 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2325 filter_data->slot_id,
2328 (bt_uuid_t*)filter_data->service_uuid,
2329 (bt_uuid_t*)filter_data->service_uuid_mask,
2332 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2334 filter_data->service_uuid_mask_len,
2337 if (ret != BT_STATUS_SUCCESS){
2338 BT_ERR("error: %s", status2string(ret));
2339 BT_INFO("unregistering already set filter features.");
2340 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2341 return convert_to_oal_status(ret);
2344 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2346 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2347 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2348 char uuid_str1[2*BT_UUID_STRING_MAX];
2349 char uuid_str2[2*BT_UUID_STRING_MAX];
2350 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2351 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2352 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2353 ret = gatt_api->client->scan_filter_add_remove(client_info,
2355 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2356 filter_data->slot_id,
2359 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2360 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2363 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2365 filter_data->service_solicitation_uuid_mask_len,
2368 if (ret != BT_STATUS_SUCCESS){
2369 BT_ERR("error: %s", status2string(ret));
2370 BT_INFO("unregistering already set filter features.");
2371 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2372 return convert_to_oal_status(ret);
2375 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2377 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2378 ret = gatt_api->client->scan_filter_add_remove(client_info,
2380 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2381 filter_data->slot_id,
2388 filter_data->service_data_len, //service_data_len as data_len in HAL
2389 (char*)filter_data->service_data,
2390 filter_data->service_data_mask_len,
2391 (char*)filter_data->service_data_mask
2393 if (ret != BT_STATUS_SUCCESS){
2394 BT_ERR("error: %s", status2string(ret));
2395 BT_INFO("unregistering already set filter features.");
2396 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2397 return convert_to_oal_status(ret);
2400 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2402 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2403 ret = gatt_api->client->scan_filter_add_remove(client_info,
2405 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2406 filter_data->slot_id,
2407 filter_data->manufacturer_id,
2413 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2414 (char*)filter_data->manufacturer_data,
2415 filter_data->manufacturer_data_mask_len,
2416 (char*)filter_data->manufacturer_data_mask
2418 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2419 if (ret != BT_STATUS_SUCCESS){
2420 BT_ERR("error: %s", status2string(ret));
2421 BT_INFO("unregistering already set filter features.");
2422 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2423 return convert_to_oal_status(ret);
2426 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2429 BT_DBG("Filter selection 0x%.2x", feature_selection);
2431 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2432 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2433 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2434 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2435 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2436 if (ret != BT_STATUS_SUCCESS){
2437 BT_ERR("error: %s", status2string(ret));
2438 return convert_to_oal_status(ret);
2440 return OAL_STATUS_SUCCESS;
2443 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2447 API_TRACE("Configure MTU Size: [%d]", mtu);
2448 CHECK_OAL_GATT_ENABLED();
2449 CHECK_CLIENT_CONNECTION(conn_id);
2451 /* To prevent crash in case other libraries not support this api */
2452 if (gatt_api->client->configure_mtu == NULL) {
2453 BT_WARN("configure_mtu is NULL");
2454 return OAL_STATUS_NOT_SUPPORT;
2457 ret = gatt_api->client->configure_mtu(conn_id, mtu);
2458 if (ret != BT_STATUS_SUCCESS) {
2459 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2460 return convert_to_oal_status(ret);
2462 return OAL_STATUS_SUCCESS;
2465 oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int server_inst_id)
2467 int ret = OAL_STATUS_SUCCESS;
2470 OAL_CHECK_PARAMETER(device_address, return);
2471 API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
2472 CHECK_OAL_GATT_ENABLED();
2473 CHECK_SERVER_INSTANCE(server_inst_id);
2474 CHECK_SERVER_REGISTRATION(server_inst_id);
2476 ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, server_inst_id);
2477 if (ret != BT_STATUS_SUCCESS) {
2478 BT_ERR("GATT connection info add failed: %s", status2string(ret));
2479 return convert_to_oal_status(ret);
2481 return OAL_STATUS_SUCCESS;