2 * Open Adaptation Layer (OAL)
4 * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <bluetooth.h>
22 #include "oal-event.h"
23 #include "oal-internal.h"
24 #include "oal-manager.h"
25 #include "oal-adapter-mgr.h"
26 #include "oal-utils.h"
28 #include "oal-common.h"
30 #define DEV_APPEARANCE 0x0000
31 #define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
32 #define MAX_PROP_LEN 95 /* SVACE WGID: 324403*/
33 #define MAX_PERM_LEN 80 //Fix for svace wgid:324402
35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
36 #define CHECK_OAL_GATT_ENABLED() \
38 if (gatt_api == NULL) { \
39 BT_ERR("GATT Not Enabled"); \
40 return OAL_STATUS_NOT_READY; \
44 #define CHECK_SERVER_INSTANCE(instance_id) \
46 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
47 BT_ERR("Invalid Instance"); \
48 return OAL_STATUS_INVALID_PARAM; \
52 #define CHECK_SERVER_REGISTRATION(instance_id) \
54 if (gatt_servers[instance_id - 1].server_id < 0) {\
55 BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
56 return OAL_STATUS_INTERNAL_ERROR;\
60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
62 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
63 if (gatt_servers[instance_id - 1].server_id == server_if) { \
64 server_inst = instance_id; \
70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
72 char * buf_str = g_malloc0(3*length + 1);\
73 if (NULL != buf_str) { \
74 convert_hex_2_str(manuf_data, length, buf_str);\
75 if (TRUE == data_type) \
76 BT_INFO("Scan Response Data:%s\n", buf_str);\
78 BT_INFO("Advertising Data:%s\n", buf_str);\
83 #define CHECK_CLIENT_REGISTRATION(client_id) \
85 if (client_id <= 0) { \
86 BT_DBG("No client registered yet...");\
87 return OAL_STATUS_INTERNAL_ERROR;\
91 #define CHECK_CLIENT_CONNECTION(conn_id) \
94 BT_ERR("No active connection");\
95 return OAL_STATUS_INTERNAL_ERROR;\
102 GATT_INS_DATA_SETTING,
114 const char *oal_device_type[] = {
125 } oal_pending_gattc_req_e;
127 static const btgatt_interface_t * gatt_api;
128 static gboolean cur_adv_state[NUM_SERVER_INST];
129 static gatt_server_t gatt_servers[NUM_SERVER_INST];
131 /* Forward declarations of GATT Server callbacks */
132 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
133 static void cb_gatts_multi_adv_enable(int server_if, int status);
134 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status);
135 static void cb_gatts_multi_adv_disable(int server_if, int status);
136 static void cb_gatts_multi_adv_update(int server_if, int status);
138 static void cb_gatts_listen(int status, int server_if);
141 static void cb_gatts_service_added(int status, int server_if, btgatt_srvc_id_t *srvc_id, int srvc_handle);
142 static void cb_gatts_included_service_added(int status, int server_if, int srvc_handle, int incl_srvc_handle);
143 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id, int srvc_handle, int char_handle);
144 static void cb_gatts_descriptor_added(int status, int server_if, bt_uuid_t *descr_id, int srvc_handle, int descr_handle);
146 static void cb_gatts_service_started(int status, int server_if, int srvc_handle);
147 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle);
148 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle);
150 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, bool is_long);
151 static void cb_gatts_request_write(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, int length,
152 bool need_rsp, bool is_prep, uint8_t* value);
153 static void cb_gatts_response_confirmation(int status, int handle);
155 static void cb_gatts_acquire_write(int fd, int conn_id, int trans_id, int attr_handle, bt_bdaddr_t*);
156 static void cb_gatts_acquire_notify(int fd, int conn_id, int trans_id, int attr_handle);
158 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
159 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
161 static void cb_gatts_mtu_changed(int conn_id, int mtu);
164 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda);
167 /************************************HAL Interface *************************************/
169 /*TODO GATT Server callbacks will be implemented in subsequent patches */
170 static const btgatt_server_callbacks_t btgatt_server_callbacks = {
171 .register_server_cb = cb_gatts_register_app,
172 .connection_cb = cb_gatts_connection,
173 .service_added_cb = cb_gatts_service_added,
174 .included_service_added_cb = cb_gatts_included_service_added,
175 .characteristic_added_cb = cb_gatts_characteristic_added,
176 .descriptor_added_cb = cb_gatts_descriptor_added,
177 .service_started_cb = cb_gatts_service_started,
178 .service_stopped_cb = cb_gatts_service_stopped,
179 .service_deleted_cb = cb_gatts_service_deleted,
180 .indication_confirmation_cb = cb_indication_confirmation,
181 .request_read_cb = cb_gatts_request_read,
182 .request_write_cb = cb_gatts_request_write,
183 .request_exec_write_cb = NULL,
184 .response_confirmation_cb = cb_gatts_response_confirmation,
185 .listen_cb = cb_gatts_listen,
186 .multi_adv_enable_cb = cb_gatts_multi_adv_enable,
187 .multi_adv_update_cb = cb_gatts_multi_adv_update,
188 .multi_adv_data_cb = cb_gatts_multi_adv_set_inst_data,
189 .multi_adv_disable_cb = cb_gatts_multi_adv_disable,
190 .mtu_changed_cb = cb_gatts_mtu_changed,
192 .notif_enabled_cb = cb_notifcation_changed,
194 .request_acquire_write_cb = cb_gatts_acquire_write,
195 .request_acquire_notify_cb = cb_gatts_acquire_notify
198 /* Forward declaration for GATT client callbacks */
199 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
200 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
201 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
202 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
203 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
204 static void cb_gattc_search_complete(int conn_id, int status);
205 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
206 btgatt_gatt_id_t *char_id, int char_prop);
207 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
208 btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
209 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
210 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
211 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
212 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
213 static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
214 btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
215 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
216 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id);
217 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu);
219 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
220 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
221 .register_client_cb = cb_gattc_register_app,
222 .scan_result_cb = cb_gattc_scan_result,
223 .open_cb = cb_gattc_connection,
224 .close_cb = cb_gattc_disconnect,
225 .search_complete_cb = cb_gattc_search_complete,
226 .search_result_cb = cb_gattc_search_result,
227 .get_characteristic_cb = cb_gattc_get_characteristics,
228 .get_descriptor_cb = cb_gattc_get_descriptor,
229 .get_included_service_cb = NULL,
230 .register_for_notification_cb = cb_gattc_register_for_notification,
231 .notify_cb = cb_gattc_notify,
232 .service_changed_cb = cb_gattc_service_changed,
233 .read_characteristic_cb = cb_gattc_read_characteristic,
234 .write_characteristic_cb = cb_gattc_write_characteristic,
235 .read_descriptor_cb = cb_gattc_read_descriptor,
236 .write_descriptor_cb = cb_gattc_write_descriptor,
237 .execute_write_cb = NULL,
238 .read_remote_rssi_cb = NULL,
239 .configure_mtu_cb = cb_gattc_configure_mtu_cmpl,
240 #ifdef PLATFORM_ANDROID_HAL
241 .scan_filter_cfg_cb = NULL,
242 .scan_filter_param_cb = NULL,
243 .scan_filter_status_cb = NULL,
244 .congestion_cb = NULL,
245 .batchscan_cfg_storage_cb = NULL,
246 .batchscan_enb_disable_cb = NULL,
247 .batchscan_reports_cb = NULL,
248 .batchscan_threshold_cb = NULL,
249 .track_adv_event_cb = NULL,
253 static btgatt_callbacks_t btgatt_callbacks = {
254 sizeof(btgatt_callbacks_t),
255 &btgatt_client_callbacks,
256 &btgatt_server_callbacks
259 /*******************************GATT Initialisation - Deinitialisation********************************/
260 oal_status_t gatt_enable(void)
262 const bt_interface_t * blued_api;
266 for (i = 0; i < NUM_SERVER_INST; i++) {
267 gatt_servers[i].server_id = -1;
268 gatt_servers[i].state = GATT_INS_DISABLED;
269 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
270 cur_adv_state[i] = FALSE;
273 /* Get stack interface */
274 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
276 if (blued_api == NULL) {
277 BT_ERR("Stack is not initialized");
278 return OAL_STATUS_NOT_READY;
282 BT_WARN("GATT Interface is already initialized...");
283 return OAL_STATUS_ALREADY_DONE;
286 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
287 if (gatt_api == NULL) {
288 BT_ERR("GATT interface failed");
289 return OAL_STATUS_INTERNAL_ERROR;
292 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
293 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
296 return convert_to_oal_status(ret);
299 BT_INFO("GATT successfully initialized");
300 return OAL_STATUS_SUCCESS;
303 oal_status_t gatt_disable(void)
311 for (i = 0; i < NUM_SERVER_INST; i++) {
312 gatt_servers[i].server_id = -1;
313 gatt_servers[i].state = GATT_INS_DISABLED;
314 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
316 return OAL_STATUS_SUCCESS;
319 /************************************GATT Server Functions*************************************/
321 oal_status_t gatts_register(oal_uuid_t* server_uuid)
323 char str[2*BT_UUID_STRING_MAX];
324 int ret = OAL_STATUS_SUCCESS;
327 CHECK_OAL_GATT_ENABLED();
328 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
329 API_TRACE("Register the server instance: UUID: [%s]", str);
331 for (i = 0; i < NUM_SERVER_INST; i++) {
332 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
333 if (gatt_servers[i].server_id != -1) {
334 BT_ERR("This is resevered UUID for easy set up application i = %d \
335 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
336 return OAL_STATUS_ALREADY_DONE;
341 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
343 if (ret != BT_STATUS_SUCCESS) {
344 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
345 return convert_to_oal_status(ret);
347 return OAL_STATUS_SUCCESS;
350 oal_status_t gatts_unregister(int instance_id)
352 int ret = OAL_STATUS_SUCCESS;
353 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
355 CHECK_OAL_GATT_ENABLED();
356 CHECK_SERVER_INSTANCE(instance_id);
357 CHECK_SERVER_REGISTRATION(instance_id);
359 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
361 if (ret != BT_STATUS_SUCCESS) {
362 BT_ERR("GATT server unregistration failed: %d", instance_id);
363 return convert_to_oal_status(ret);
366 gatt_servers[instance_id-1].server_id = -1;
367 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
369 if (instance_id != 1 && instance_id != 2)
370 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
372 return OAL_STATUS_SUCCESS;
375 /* Legacy Advertisement */
376 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
378 int ret = OAL_STATUS_SUCCESS;
379 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
381 CHECK_OAL_GATT_ENABLED();
382 CHECK_SERVER_INSTANCE(instance_id);
383 CHECK_SERVER_REGISTRATION(instance_id);
385 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
387 if (ret != BT_STATUS_SUCCESS) {
388 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
389 gatt_servers[instance_id-1].server_id, status2string(ret));
390 return convert_to_oal_status(ret);
393 return OAL_STATUS_SUCCESS;
396 oal_status_t gatts_stop_advertising(int instance_id)
398 int ret = OAL_STATUS_SUCCESS;
399 API_TRACE("Stop advertising");
401 CHECK_OAL_GATT_ENABLED();
402 CHECK_SERVER_INSTANCE(instance_id);
403 CHECK_SERVER_REGISTRATION(instance_id);
405 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
407 if (ret != BT_STATUS_SUCCESS) {
408 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
409 instance_id, status2string(ret));
410 return convert_to_oal_status(ret);
412 return OAL_STATUS_SUCCESS;
416 /* Below API's need to be removed as they are hardcoded API's.
417 If at all, product specific API's are required to set specific data, then new naming should
418 be adopted for these API's */
419 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
421 int ret = OAL_STATUS_SUCCESS;
423 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
424 CHECK_OAL_GATT_ENABLED();
425 CHECK_SERVER_INSTANCE(instance_id);
426 CHECK_SERVER_REGISTRATION(instance_id);
428 /* Historically used for Legacy Advertising */
429 return OAL_STATUS_NOT_SUPPORT;
432 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
434 int ret = OAL_STATUS_SUCCESS;
436 API_TRACE("Set advertising data");
437 CHECK_OAL_GATT_ENABLED();
438 CHECK_SERVER_INSTANCE(instance_id);
439 CHECK_SERVER_REGISTRATION(instance_id);
441 /* Historically used for Legacy Advertising */
442 return OAL_STATUS_NOT_SUPPORT;
445 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
447 int ret = OAL_STATUS_SUCCESS;
449 API_TRACE("Set Scan Response data");
450 CHECK_OAL_GATT_ENABLED();
451 CHECK_SERVER_INSTANCE(instance_id);
452 CHECK_SERVER_REGISTRATION(instance_id);
454 /* Historically used for Legacy Advertising */
455 return OAL_STATUS_NOT_SUPPORT;
459 oal_status_t gatts_multi_adv_enable(int instance_id)
461 int ret = OAL_STATUS_SUCCESS;
462 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
463 gatt_servers[instance_id - 1].server_id, instance_id);
465 CHECK_OAL_GATT_ENABLED();
466 CHECK_SERVER_INSTANCE(instance_id);
467 CHECK_SERVER_REGISTRATION(instance_id);
469 if (gatt_api->server->multi_adv_enable == NULL)
470 return OAL_STATUS_NOT_SUPPORT;
472 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
473 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
474 BT_ERR("Not allowed, state: %d, instance_id: %d",
475 gatt_servers[instance_id - 1].state, instance_id);
476 return OAL_STATUS_BUSY;
479 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
480 BT_ERR("Not allowed, state: %d, instance_id: %d",
481 gatt_servers[instance_id - 1].state, instance_id);
482 return OAL_STATUS_ALREADY_DONE;
485 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
486 BT_ERR("Not allowed, state: %d, instance_id: %d",
487 gatt_servers[instance_id - 1].state, instance_id);
488 return OAL_STATUS_BUSY;
491 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
493 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
495 if (ret != BT_STATUS_SUCCESS) {
496 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
497 instance_id, status2string(ret));
498 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
499 return convert_to_oal_status(ret);
501 return OAL_STATUS_SUCCESS;
504 oal_status_t gatts_multi_adv_disable(int instance_id)
506 int ret = OAL_STATUS_SUCCESS;
507 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
508 gatt_servers[instance_id - 1].server_id, instance_id);
510 CHECK_OAL_GATT_ENABLED();
511 CHECK_SERVER_INSTANCE(instance_id);
512 CHECK_SERVER_REGISTRATION(instance_id);
514 if (gatt_api->server->multi_adv_disable == NULL)
515 return OAL_STATUS_NOT_SUPPORT;
517 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
518 BT_ERR("Not Allowed, state: %d, instance_id: %d",
519 gatt_servers[instance_id - 1].state, instance_id);
520 return OAL_STATUS_BUSY;
523 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
525 if (ret != BT_STATUS_SUCCESS) {
526 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
527 instance_id, status2string(ret));
528 return convert_to_oal_status(ret);
530 return OAL_STATUS_SUCCESS;
533 oal_status_t gatts_set_filter_policy(int filter_policy)
535 int ret = OAL_STATUS_SUCCESS;
537 CHECK_OAL_GATT_ENABLED();
539 /* send the filter_policy value to the HAL Layer */
540 ret = gatt_api->server->set_filter_policy(filter_policy);
542 if (ret != BT_STATUS_SUCCESS) {
543 BT_ERR("set_filter_policy failed: %d",ret);
544 return convert_to_oal_status(ret);
547 return OAL_STATUS_SUCCESS;
550 oal_status_t gatts_multi_adv_update(int instance_id,
551 int min_intv, int max_intv,
552 int adv_type, int chnl_map,
553 int tx_power, int timeout_s)
555 int ret = OAL_STATUS_SUCCESS;
556 API_TRACE("Multi advertising Update");
558 CHECK_OAL_GATT_ENABLED();
559 CHECK_SERVER_INSTANCE(instance_id);
560 CHECK_SERVER_REGISTRATION(instance_id);
562 if (gatt_api->server->multi_adv_update == NULL)
563 return OAL_STATUS_NOT_SUPPORT;
565 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
568 tx_power, timeout_s);
570 if (ret != BT_STATUS_SUCCESS) {
571 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
572 instance_id, status2string(ret));
573 return convert_to_oal_status(ret);
575 return OAL_STATUS_SUCCESS;
578 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
579 oal_ble_multi_adv_param_setup_t *adv_param_setup)
581 int ret = OAL_STATUS_SUCCESS;
582 btgatt_adv_param_setup_t adv_setup;
583 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
584 gatt_servers[instance_id - 1].server_id, instance_id);
586 CHECK_OAL_GATT_ENABLED();
587 CHECK_SERVER_INSTANCE(instance_id);
588 CHECK_SERVER_REGISTRATION(instance_id);
590 if (gatt_api->server->multi_adv_set_inst_data == NULL)
591 return OAL_STATUS_NOT_SUPPORT;
593 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
594 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
595 return OAL_STATUS_BUSY;
598 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
601 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
602 adv_setup.include_name = adv_param_setup->include_name;
603 adv_setup.include_txpower = adv_param_setup->include_txpower;
604 adv_setup.appearance = adv_param_setup->appearance;
605 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
606 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
607 adv_setup.service_data = adv_param_setup->service_data;
608 adv_setup.service_data_len = adv_param_setup->service_data_len;
609 adv_setup.service_uuid = adv_param_setup->service_uuid;
610 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
611 /* Solicit UUID handler: Start */
612 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
613 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
614 /* Solicit UUID handler: End */
615 adv_setup.min_interval = adv_param_setup->min_interval;
616 adv_setup.max_interval = adv_param_setup->min_interval;
617 adv_setup.adv_type = adv_param_setup->adv_type;
618 adv_setup.chnl_map = adv_param_setup->chnl_map;
619 adv_setup.tx_power = adv_param_setup->tx_power;
620 adv_setup.timeout_s = adv_param_setup->timeout_s;
622 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
624 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
625 if (ret != BT_STATUS_SUCCESS) {
626 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
627 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
628 return convert_to_oal_status(ret);
630 return OAL_STATUS_SUCCESS;
633 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
635 int ret = OAL_STATUS_SUCCESS;
638 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
640 CHECK_OAL_GATT_ENABLED();
641 CHECK_SERVER_INSTANCE(instance_id);
642 CHECK_SERVER_REGISTRATION(instance_id);
644 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
646 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
647 if (ret != BT_STATUS_SUCCESS) {
648 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
649 return convert_to_oal_status(ret);
651 return OAL_STATUS_SUCCESS;
655 /************************************GATT Server Functions*************************************/
657 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
660 char str[2*BT_UUID_STRING_MAX];
661 uuid_to_stringname((service_uuid_t*)uuid, str);
663 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
665 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
666 BT_INFO("UUID: [%s]", str);
668 for (i = 0; i < NUM_SERVER_INST; i++) {
669 if (gatt_servers[i].server_id == -1) {
670 BT_INFO("Server Instance registered with stack [%d]", i+1);
671 gatt_servers[i].server_id = server_if;
672 event->server_inst = i+1;
673 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
674 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
678 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
681 static void cb_gatts_listen(int status, int server_if)
683 gboolean prev_state[NUM_SERVER_INST];
685 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
688 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
689 if (gatt_servers[instance_id - 1].server_id == server_if) {
690 event->server_inst = instance_id;
693 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
696 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
697 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
698 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
699 cur_adv_state[event->server_inst - 1] = new_state;
701 BT_ERR("Invalid Callback...");
706 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
708 if (TRUE == new_state)
709 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
711 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
714 static void cb_gatts_multi_adv_enable(int server_if, int status)
717 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
718 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
721 if (status != BT_STATUS_SUCCESS)
722 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
724 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
725 if (gatt_servers[instance_id - 1].server_id == server_if) {
726 event->server_inst = instance_id;
727 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
731 BT_ERR("Invalid Interface, srv_if: %d", server_if);
732 event->server_inst = -1;
734 event->status = convert_to_oal_status(status);
735 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
738 static void cb_gatts_multi_adv_disable(int server_if, int status)
740 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
741 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
744 if (status != BT_STATUS_SUCCESS)
745 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
747 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
748 if (gatt_servers[instance_id - 1].server_id == server_if) {
749 event->server_inst = instance_id;
750 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
754 BT_ERR("Invalid Interface, srv_if: %d", server_if);
755 event->server_inst = -1;
757 event->status = convert_to_oal_status(status);
758 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
761 static void cb_gatts_multi_adv_update(int server_if, int status)
763 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
764 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
767 if (status != BT_STATUS_SUCCESS)
768 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
770 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
771 if (gatt_servers[instance_id - 1].server_id == server_if) {
772 event->server_inst = instance_id;
776 BT_ERR("Invalid Interface, srv_if: %d", server_if);
777 event->server_inst = -1;
779 event->status = convert_to_oal_status(status);
780 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
783 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
785 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
786 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
789 if (status != BT_STATUS_SUCCESS)
790 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
792 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
793 if (gatt_servers[instance_id - 1].server_id == server_if) {
794 event->server_inst = instance_id;
795 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
799 BT_ERR("Invalid Interface, srv_if: %d", server_if);
800 event->server_inst = -1;
802 event->status = convert_to_oal_status(status);
803 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
806 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
808 int ret = OAL_STATUS_SUCCESS;
809 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
810 CHECK_OAL_GATT_ENABLED();
811 OAL_CHECK_PARAMETER(mtu, return);
813 /* To prevent crash in case other libraries not support this api */
814 if (gatt_api->server->get_att_mtu == NULL) {
815 BT_WARN("get_att_mtu is NULL");
816 return OAL_STATUS_NOT_SUPPORT;
819 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
820 if (ret != BT_STATUS_SUCCESS) {
821 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
822 return convert_to_oal_status(ret);
825 BT_INFO("Current ATT MTU Size: %d", *mtu);
826 return OAL_STATUS_SUCCESS;
828 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
829 int status, int fd, int mtu , void * fdlist)
831 int ret = OAL_STATUS_SUCCESS;
833 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
834 CHECK_OAL_GATT_ENABLED();
836 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
837 if (ret != BT_STATUS_SUCCESS) {
838 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
839 return convert_to_oal_status(ret);
841 return OAL_STATUS_SUCCESS;
844 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
847 int ret = OAL_STATUS_SUCCESS;
848 btgatt_srvc_id_t btgatt_srvc_id;
849 char str[2*BT_UUID_STRING_MAX];
851 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
852 CHECK_OAL_GATT_ENABLED();
854 CHECK_SERVER_INSTANCE(instance_id);
855 CHECK_SERVER_REGISTRATION(instance_id);
857 if (gatt_serv_id != NULL) {
858 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
859 API_TRACE("Service uuid: [%s]", str);
860 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
861 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
862 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
864 BT_INFO("GATT Server Service Id is NULL");
865 return OAL_STATUS_INVALID_PARAM;
868 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
870 if (ret != BT_STATUS_SUCCESS) {
871 BT_ERR("GATT Server add service failed: %s", status2string(ret));
872 return convert_to_oal_status(ret);
874 return OAL_STATUS_SUCCESS;
877 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
880 int ret = OAL_STATUS_SUCCESS;
881 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
882 instance_id, serv_handle, incl_handle);
883 CHECK_OAL_GATT_ENABLED();
885 CHECK_SERVER_INSTANCE(instance_id);
887 CHECK_SERVER_REGISTRATION(instance_id);
889 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
890 if (ret != BT_STATUS_SUCCESS) {
891 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
892 return convert_to_oal_status(ret);
894 return OAL_STATUS_SUCCESS;
897 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
898 oal_uuid_t* charc_uuid, int propts, int permsn)
900 int ret = OAL_STATUS_SUCCESS;
901 char str[2*BT_UUID_STRING_MAX];
902 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
903 char_prop_to_string(propts, prop);
904 char_perm_to_string(permsn, perm);
905 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
906 instance_id, serv_handle, prop, perm);
907 CHECK_OAL_GATT_ENABLED();
909 CHECK_SERVER_INSTANCE(instance_id);
911 CHECK_SERVER_REGISTRATION(instance_id);
913 if (charc_uuid != NULL) {
914 uuid_to_stringname(charc_uuid, str);
915 API_TRACE("uuid: [%s]", str);
918 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
919 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
920 if (ret != BT_STATUS_SUCCESS) {
921 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
922 return convert_to_oal_status(ret);
924 return OAL_STATUS_SUCCESS;
927 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
928 oal_uuid_t* desc_uuid, int permsn)
930 int ret = OAL_STATUS_SUCCESS;
931 char str[2*BT_UUID_STRING_MAX];
932 char perm[MAX_PERM_LEN];
933 char_perm_to_string(permsn, perm);
934 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
935 instance_id, serv_handle, perm);
936 CHECK_OAL_GATT_ENABLED();
938 CHECK_SERVER_INSTANCE(instance_id);
940 CHECK_SERVER_REGISTRATION(instance_id);
942 if (desc_uuid != NULL) {
943 uuid_to_stringname(desc_uuid, str);
944 API_TRACE("uuid: [%s]", str);
947 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
948 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
950 if (ret != BT_STATUS_SUCCESS) {
951 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
952 return convert_to_oal_status(ret);
954 return OAL_STATUS_SUCCESS;
957 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
959 int ret = OAL_STATUS_SUCCESS;
961 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
962 instance_id, svc_handle, transport);
963 CHECK_OAL_GATT_ENABLED();
965 CHECK_SERVER_INSTANCE(instance_id);
967 CHECK_SERVER_REGISTRATION(instance_id);
969 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
971 if (ret != BT_STATUS_SUCCESS) {
972 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
973 return convert_to_oal_status(ret);
975 return OAL_STATUS_SUCCESS;
978 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
980 int ret = OAL_STATUS_SUCCESS;
982 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
983 CHECK_OAL_GATT_ENABLED();
985 CHECK_SERVER_INSTANCE(ins_id);
986 CHECK_SERVER_REGISTRATION(ins_id);
988 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
989 if (ret != BT_STATUS_SUCCESS) {
990 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
991 return convert_to_oal_status(ret);
993 return OAL_STATUS_SUCCESS;
996 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
998 int ret = OAL_STATUS_SUCCESS;
1000 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1001 CHECK_OAL_GATT_ENABLED();
1003 CHECK_SERVER_INSTANCE(ins_id);
1005 CHECK_SERVER_REGISTRATION(ins_id);
1007 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
1008 if (ret != BT_STATUS_SUCCESS) {
1009 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1010 return convert_to_oal_status(ret);
1012 return OAL_STATUS_SUCCESS;
1015 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1017 int ret = OAL_STATUS_SUCCESS;
1019 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1020 CHECK_OAL_GATT_ENABLED();
1022 if (response == NULL) {
1023 BT_ERR("GATT Server attribute value is empty");
1024 return OAL_STATUS_INVALID_PARAM;
1027 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1028 if (ret != BT_STATUS_SUCCESS) {
1029 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1030 return convert_to_oal_status(ret);
1032 return OAL_STATUS_SUCCESS;
1035 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1037 int ret = OAL_STATUS_SUCCESS;
1039 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1040 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1041 CHECK_OAL_GATT_ENABLED();
1043 CHECK_SERVER_INSTANCE(ins_id);
1045 CHECK_SERVER_REGISTRATION(ins_id);
1047 if (value == NULL || len == 0) {
1048 BT_ERR("GATT Server attribute value is empty");
1049 return OAL_STATUS_INVALID_PARAM;
1052 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1053 attr_hndl, conn_id, len, confirm, value);
1055 if (ret != BT_STATUS_SUCCESS) {
1056 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1057 return convert_to_oal_status(ret);
1059 return OAL_STATUS_SUCCESS;
1062 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1064 int ret = OAL_STATUS_SUCCESS;
1066 CHECK_OAL_GATT_ENABLED();
1068 CHECK_SERVER_INSTANCE(ins_id);
1070 CHECK_SERVER_REGISTRATION(ins_id);
1072 if (value == NULL || value->len == 0) {
1073 BT_ERR("GATT Server attribute value is empty");
1074 return OAL_STATUS_INVALID_PARAM;
1077 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1078 ins_id, value->handle, value->len);
1080 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1081 (int)value->handle, (int)value->len, (char*)value->value);
1083 if (ret != BT_STATUS_SUCCESS) {
1084 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1085 return convert_to_oal_status(ret);
1087 return OAL_STATUS_SUCCESS;
1090 /* GATT Server Callbacks:Start */
1091 static void cb_gatts_service_added(int status, int server_if,
1092 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1096 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1097 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1099 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1101 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1102 event->gatt_srvc_stat.server_inst = -1;
1104 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1105 if (psrvc_id != NULL) {
1106 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1107 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1108 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1109 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1112 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1114 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1117 static void cb_gatts_included_service_added(int status, int server_if,
1119 int incl_srvc_handle)
1122 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1123 status, srvc_handle, incl_srvc_handle);
1125 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1127 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1129 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1130 event->gatt_srvc_stat.server_inst = -1;
1132 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1133 event->incl_srvc_hndl = incl_srvc_handle;
1134 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1135 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1138 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1139 int srvc_handle, int char_handle)
1143 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1144 status, srvc_handle, char_handle);
1146 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1148 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1150 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1151 event->gatt_srvc_stat.server_inst = -1;
1153 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1154 event->charctr_hndl = char_handle;
1155 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1156 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1157 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1160 static void cb_gatts_descriptor_added(int status, int server_if,
1161 bt_uuid_t *descr_id, int srvc_handle,
1165 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1166 status, srvc_handle, descr_handle);
1168 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1170 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1172 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1173 event->gatt_srvc_stat.server_inst = -1;
1175 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1176 event->descrptr_hndl = descr_handle;
1177 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1178 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1179 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1182 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1185 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1187 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1189 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1191 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1192 event->server_inst = -1;
1194 event->servic_hndl = srvc_handle;
1195 event->status = convert_to_oal_status(status);
1196 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1199 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1202 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1204 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1206 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1208 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1209 event->server_inst = -1;
1211 event->servic_hndl = srvc_handle;
1212 event->status = convert_to_oal_status(status);
1213 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1216 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1219 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1221 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1223 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1225 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1226 event->server_inst = -1;
1228 event->servic_hndl = srvc_handle;
1229 event->status = convert_to_oal_status(status);
1230 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1233 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1236 oal_event_t event_type;
1238 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1239 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1241 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1242 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1243 event->server_inst = ins_id;
1246 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1249 if (ins_id == NUM_SERVER_INST+1) {
1250 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1254 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1255 event->conn_id = conn_id;
1256 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1257 event->status = OAL_STATUS_SUCCESS;
1259 send_event(event_type, event, sizeof(event_gatts_conn_t));
1262 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1263 int attr_handle, int offset, bool is_long)
1265 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1267 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1269 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1271 event->attr_trans.attr_handle = attr_handle;
1272 event->attr_trans.conn_id = conn_id;
1273 event->attr_trans.trans_id = trans_id;
1274 event->attr_trans.offset = offset;
1275 event->is_long = is_long;
1277 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1280 static void cb_gatts_request_write(int conn_id, int trans_id,
1281 bt_bdaddr_t *bda, int attr_handle,
1282 int offset, int length,
1283 bool need_rsp, bool is_prep, uint8_t* value)
1285 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1287 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1289 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1291 event->attr_trans.attr_handle = attr_handle;
1292 event->attr_trans.conn_id = conn_id;
1293 event->attr_trans.trans_id = trans_id;
1294 event->attr_trans.offset = offset;
1295 event->need_rsp = need_rsp;
1296 event->is_prep = is_prep;
1298 if (length > 0 && value != NULL) {
1299 if (length > OAL_GATT_MAX_ATTR_LEN)
1300 length = OAL_GATT_MAX_ATTR_LEN;
1301 memcpy(event->value, value, length);
1302 event->length = length;
1304 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1307 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1310 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1312 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1314 event->attr_trans.attr_handle = attr_handle;
1315 event->attr_trans.conn_id = conn_id;
1316 event->attr_trans.trans_id = trans_id;
1318 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1320 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1323 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1325 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1327 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1329 event->attr_trans.attr_handle = attr_handle;
1330 event->attr_trans.conn_id = conn_id;
1331 event->attr_trans.trans_id = trans_id;
1334 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1338 static void cb_gatts_response_confirmation(int status, int handle)
1340 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1342 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1344 event->hndl = handle;
1345 event->status = convert_to_oal_status(status);
1347 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1350 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1352 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1353 conn_id, trans_id, attr_handle);
1355 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1357 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1359 event->attr_handle = attr_handle;
1360 event->conn_id = conn_id;
1361 event->trans_id = trans_id;
1362 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1365 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1367 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1368 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1369 event->conn_id = conn_id;
1370 event->mtu_size = mtu;
1371 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1375 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1377 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1378 conn_id, trans_id, attr_handle, notify);
1380 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1382 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1384 event->attr_handle = attr_handle;
1385 event->conn_id = conn_id;
1386 event->trans_id = trans_id;
1387 event->notify = notify;
1388 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1393 /* GATT Server Callbacks: End */
1394 /************************************ GATT Client ***********************************/
1395 /* Client Callbacks */
1396 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1398 char uuid_str[BT_UUID_STRING_MAX];
1399 event_gattc_register_t *event;
1401 /* Check if GATT client registered for Default GATT client UUID */
1402 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1404 BT_INFO("GATT CLIENT REGISTER APP CB, status:%d, clientIf:%d, %s", status, clientIf, uuid_str);
1405 event = g_new0(event_gattc_register_t, 1);
1406 event->client_if = clientIf;
1407 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1408 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1409 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1412 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1414 event_ble_scan_result_info *event;
1416 event = g_new0(event_ble_scan_result_info, 1);
1418 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1419 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1420 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1421 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1424 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1426 event_gattc_conn_t *event;
1427 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1428 status, client_if, conn_id);
1430 event = g_new0(event_gattc_conn_t, 1);
1431 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1432 event->client_if = client_if;
1434 if (BT_STATUS_SUCCESS != status) {
1435 event->status = OAL_STATUS_INTERNAL_ERROR;
1436 BT_ERR("gattc connection Error: %d", status);
1438 event->conn_id = conn_id;
1439 event->status = OAL_STATUS_SUCCESS;
1442 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1443 sizeof(*event), (bt_address_t *)bda);
1447 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1449 event_gattc_conn_t *event;
1450 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1451 status, client_if, conn_id);
1452 event = g_new0(event_gattc_conn_t, 1);
1453 event->status = convert_to_oal_status(status);
1454 event->client_if = client_if;
1455 event->conn_id = conn_id;
1456 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1457 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1458 sizeof(*event), (bt_address_t *)bda);
1461 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1463 char uuid_str[2*BT_UUID_STRING_MAX];
1465 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1467 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1468 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1469 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1471 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1472 event->conn_status.status = OAL_STATUS_SUCCESS;
1473 event->conn_status.conn_id = conn_id;
1474 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1476 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1479 static void cb_gattc_search_complete(int conn_id, int status)
1481 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1484 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1485 event->conn_id = conn_id;
1486 event->status = convert_to_oal_status(status);
1488 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1492 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1493 btgatt_gatt_id_t *char_id, int char_prop)
1495 char uuid_str1[2*BT_UUID_STRING_MAX];
1496 char uuid_str2[2*BT_UUID_STRING_MAX];
1499 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1500 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1501 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1502 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1504 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1505 event->conn_status.conn_id = conn_id;
1506 event->conn_status.status = convert_to_oal_status(status);
1507 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1510 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1511 BT_INFO("Charac => [%s], Inst_id [%u], Prop [%s]",
1512 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1513 event->char_prop = char_prop;
1514 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1516 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1521 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id)
1523 char uuid_str1[2*BT_UUID_STRING_MAX];
1524 char uuid_str2[2*BT_UUID_STRING_MAX];
1525 char uuid_str3[2*BT_UUID_STRING_MAX];
1526 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1527 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1528 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1529 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1530 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1531 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1533 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1534 event->conn_status.conn_id = conn_id;
1535 event->conn_status.status = convert_to_oal_status(status);
1536 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1537 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1540 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1541 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, descr_id->inst_id);
1542 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1544 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1547 static void cb_gattc_register_for_notification(int client_if, int registered, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id)
1549 char uuid_str1[2*BT_UUID_STRING_MAX];
1550 char uuid_str2[2*BT_UUID_STRING_MAX];
1551 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1552 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1553 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1554 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1555 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1556 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1558 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1559 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1560 event->client_if = client_if;
1561 event->status = convert_to_oal_status(status);
1562 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1563 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1565 send_event(event_type, event, sizeof(*event));
1568 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1571 char uuid_str1[2*BT_UUID_STRING_MAX];
1572 char uuid_str2[2*BT_UUID_STRING_MAX];
1574 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1575 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1576 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1578 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1579 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1581 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1582 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1583 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1585 if (p_data->len > 0) {
1587 data = g_malloc(3*p_data->len+1);
1589 BT_ERR("memory allocation failed");
1593 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1594 BT_INFO("Notified Data: [%s]", data);
1596 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1597 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1598 event->is_notify = p_data->is_notify;
1599 event->data_len = p_data->len;
1600 memcpy(event->data, p_data->value, event->data_len);
1601 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1602 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1604 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1609 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id)
1611 event_gattc_service_changed_data *event = g_new0(event_gattc_service_changed_data, 1);
1613 memcpy(event->address.addr, bd_addr->address, 6);
1614 event->change_type = change_type;
1615 memcpy(event->uuid.uuid, uuid, sizeof(event->uuid.uuid));
1616 event->conn_id = conn_id;
1617 event->inst_id = inst_id;
1619 send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
1622 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1624 char uuid_str1[2*BT_UUID_STRING_MAX];
1625 char uuid_str2[2*BT_UUID_STRING_MAX];
1626 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1628 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1629 event->uuid_status.conn_status.conn_id = conn_id;
1630 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1631 event->value_type = p_data->value_type;
1632 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1633 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1635 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1636 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1637 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1638 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1639 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1640 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1641 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1643 data = g_malloc(3*p_data->value.len+1);
1645 BT_ERR("memory allocation failed");
1649 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1650 BT_DBG("Read Data: [%s]", data);
1651 event->data_len = p_data->value.len;
1652 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1656 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1659 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1661 char uuid_str1[2*BT_UUID_STRING_MAX];
1662 char uuid_str2[2*BT_UUID_STRING_MAX];
1663 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1665 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1666 event->conn_status.conn_id = conn_id;
1667 event->conn_status.status = convert_to_oal_status(status);
1668 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1669 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1671 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1672 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1673 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1674 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1675 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1677 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1680 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1682 char uuid_str1[2*BT_UUID_STRING_MAX];
1683 char uuid_str2[2*BT_UUID_STRING_MAX];
1684 char uuid_str3[2*BT_UUID_STRING_MAX];
1685 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1687 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1688 event->conn_status.conn_id = conn_id;
1689 event->conn_status.status = convert_to_oal_status(status);
1690 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1691 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1692 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1694 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1695 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1696 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1697 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1698 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1699 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1700 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1702 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1707 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1709 char uuid_str1[2*BT_UUID_STRING_MAX];
1710 char uuid_str2[2*BT_UUID_STRING_MAX];
1711 char uuid_str3[2*BT_UUID_STRING_MAX];
1712 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1714 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1715 event->uuid_status.conn_status.conn_id = conn_id;
1716 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1717 event->value_type = p_data->value_type;
1718 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1719 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1720 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1723 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1724 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1725 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1726 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1727 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1728 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1729 BT_INFO("Desc => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1730 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1731 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1733 data = g_malloc(3*p_data->value.len+1);
1735 BT_ERR("memory allocation failed");
1739 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1740 BT_DBG("Read Data: [%s]", data);
1741 event->data_len = p_data->value.len;
1742 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1746 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1749 oal_status_t gattc_start_le_discovery(int client_id)
1752 int ret = OAL_STATUS_SUCCESS;
1754 API_TRACE("BTGATT CLIENT SCAN START");
1755 CHECK_OAL_GATT_ENABLED();
1756 CHECK_CLIENT_REGISTRATION(client_id);
1758 ret = gatt_api->client->scan(client_id, 1);
1759 if (ret != BT_STATUS_SUCCESS) {
1760 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1761 return convert_to_oal_status(ret);
1763 return OAL_STATUS_SUCCESS;
1766 oal_status_t gattc_stop_le_discovery(int client_id)
1769 int ret = OAL_STATUS_SUCCESS;
1771 API_TRACE("Scan is stopped");
1772 CHECK_OAL_GATT_ENABLED();
1773 CHECK_CLIENT_REGISTRATION(client_id);
1774 ret = gatt_api->client->scan(client_id, 0);
1775 if (ret != BT_STATUS_SUCCESS) {
1776 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1777 return convert_to_oal_status(ret);
1779 return OAL_STATUS_SUCCESS;
1782 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1786 API_TRACE("Scan is stopped");
1787 CHECK_OAL_GATT_ENABLED();
1790 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1791 if (ret != BT_STATUS_SUCCESS) {
1792 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1793 return convert_to_oal_status(ret);
1796 ret = gatt_api->client->set_scan_parameters(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);
1803 return OAL_STATUS_SUCCESS;
1806 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1808 event_gattc_mtu_configured_t *event;
1809 BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1810 conn_id, status, mtu);
1811 event = g_new0(event_gattc_mtu_configured_t, 1);
1812 event->conn_id = conn_id;
1814 event->status = convert_to_oal_status(status);
1815 send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1818 /************************************ GATT Client ***********************************/
1819 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1822 char str[2*BT_UUID_STRING_MAX];
1823 int ret = OAL_STATUS_SUCCESS;
1825 CHECK_OAL_GATT_ENABLED();
1826 uuid_to_stringname(client_uuid, str);
1827 API_TRACE("uuid: [%s]", str);
1828 /* We will perform actual registration in cb_gattc_register_app callback */
1829 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1830 if (ret != BT_STATUS_SUCCESS) {
1831 BT_ERR("GATT client register failed: %s", status2string(ret));
1832 return convert_to_oal_status(ret);
1834 return OAL_STATUS_SUCCESS;
1837 oal_status_t gattc_deregister(int client_id)
1839 int ret = OAL_STATUS_SUCCESS;
1841 API_TRACE("GATT client deregister");
1842 CHECK_OAL_GATT_ENABLED();
1843 CHECK_CLIENT_REGISTRATION(client_id);
1845 ret = gatt_api->client->unregister_client(client_id);
1846 if (ret != BT_STATUS_SUCCESS) {
1847 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1848 return convert_to_oal_status(ret);
1851 return OAL_STATUS_SUCCESS;
1854 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1856 int ret = OAL_STATUS_SUCCESS;
1859 OAL_CHECK_PARAMETER(device_address, return);
1860 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1861 CHECK_OAL_GATT_ENABLED();
1862 CHECK_CLIENT_REGISTRATION(client_id);
1864 /* Handle the actual connection in cb_gattc_connection callback */
1865 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1866 if (ret != BT_STATUS_SUCCESS) {
1867 BT_ERR("GATT client connect failed: %s", status2string(ret));
1868 return convert_to_oal_status(ret);
1870 return OAL_STATUS_SUCCESS;
1873 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1876 int ret = OAL_STATUS_SUCCESS;
1879 OAL_CHECK_PARAMETER(device_address, return);
1880 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1881 CHECK_OAL_GATT_ENABLED();
1882 CHECK_CLIENT_REGISTRATION(client_id);
1883 CHECK_CLIENT_CONNECTION(conn_id);
1885 /* Handle actual disconnection in callback */
1886 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1887 if (ret != BT_STATUS_SUCCESS) {
1888 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1889 return convert_to_oal_status(ret);
1891 return OAL_STATUS_SUCCESS;
1895 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1897 int ret = OAL_STATUS_SUCCESS;
1898 char uuid_str[2*BT_UUID_STRING_MAX];
1901 uuid_to_stringname(service_uuid, uuid_str);
1902 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1904 API_TRACE("Client Service Search All");
1906 CHECK_OAL_GATT_ENABLED();
1907 CHECK_CLIENT_CONNECTION(conn_id);
1908 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1910 if (ret != BT_STATUS_SUCCESS) {
1911 BT_ERR("GATT client service search failed: %s", status2string(ret));
1912 return convert_to_oal_status(ret);
1914 return OAL_STATUS_SUCCESS;
1917 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1919 int ret = OAL_STATUS_SUCCESS;
1920 char uuid_str[2*BT_UUID_STRING_MAX];
1922 OAL_CHECK_PARAMETER(srvc_id, return);
1923 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1924 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1925 CHECK_OAL_GATT_ENABLED();
1926 CHECK_CLIENT_CONNECTION(conn_id);
1927 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1928 (btgatt_gatt_id_t *)char_id);
1929 if (ret != BT_STATUS_SUCCESS) {
1930 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1931 return convert_to_oal_status(ret);
1933 return OAL_STATUS_SUCCESS;
1936 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1937 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1939 int ret = OAL_STATUS_SUCCESS;
1940 char uuid_str1[2*BT_UUID_STRING_MAX];
1941 char uuid_str2[2*BT_UUID_STRING_MAX];
1943 OAL_CHECK_PARAMETER(srvc_id, return);
1944 OAL_CHECK_PARAMETER(char_id, return);
1945 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1946 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1947 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1948 CHECK_OAL_GATT_ENABLED();
1949 CHECK_CLIENT_CONNECTION(conn_id);
1950 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1951 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1952 if (ret != BT_STATUS_SUCCESS) {
1953 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1954 return convert_to_oal_status(ret);
1956 return OAL_STATUS_SUCCESS;
1959 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1960 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1961 int ret = OAL_STATUS_SUCCESS;
1962 char uuid_str1[2*BT_UUID_STRING_MAX];
1963 char uuid_str2[2*BT_UUID_STRING_MAX];
1966 OAL_CHECK_PARAMETER(address, return);
1967 OAL_CHECK_PARAMETER(srvc_id, return);
1968 OAL_CHECK_PARAMETER(char_id, return);
1969 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1970 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1971 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1972 CHECK_OAL_GATT_ENABLED();
1973 CHECK_CLIENT_REGISTRATION(client_id);
1975 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);
1976 if (ret != BT_STATUS_SUCCESS) {
1977 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1978 return convert_to_oal_status(ret);
1981 return OAL_STATUS_SUCCESS;
1984 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1985 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1986 int ret = OAL_STATUS_SUCCESS;
1987 char uuid_str1[2*BT_UUID_STRING_MAX];
1988 char uuid_str2[2*BT_UUID_STRING_MAX];
1991 OAL_CHECK_PARAMETER(address, return);
1992 OAL_CHECK_PARAMETER(srvc_id, return);
1993 OAL_CHECK_PARAMETER(char_id, return);
1994 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1995 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1996 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1997 CHECK_OAL_GATT_ENABLED();
1998 CHECK_CLIENT_REGISTRATION(client_id);
2000 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);
2001 if (ret != BT_STATUS_SUCCESS) {
2002 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2003 return convert_to_oal_status(ret);
2006 return OAL_STATUS_SUCCESS;
2010 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2011 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2013 int ret = OAL_STATUS_SUCCESS;
2014 char uuid_str1[2*BT_UUID_STRING_MAX];
2015 char uuid_str2[2*BT_UUID_STRING_MAX];
2017 OAL_CHECK_PARAMETER(srvc_id, return);
2018 OAL_CHECK_PARAMETER(char_id, return);
2019 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2020 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2021 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2022 CHECK_OAL_GATT_ENABLED();
2023 CHECK_CLIENT_CONNECTION(conn_id);
2025 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2026 (btgatt_gatt_id_t *)char_id, auth_req);
2027 if (ret != BT_STATUS_SUCCESS) {
2028 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2029 return convert_to_oal_status(ret);
2032 return OAL_STATUS_SUCCESS;
2035 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2036 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2038 int ret = OAL_STATUS_SUCCESS;
2039 char uuid_str1[2*BT_UUID_STRING_MAX];
2040 char uuid_str2[2*BT_UUID_STRING_MAX];
2041 char uuid_str3[2*BT_UUID_STRING_MAX];
2043 OAL_CHECK_PARAMETER(srvc_id, return);
2044 OAL_CHECK_PARAMETER(char_id, return);
2045 OAL_CHECK_PARAMETER(desc_id, return);
2046 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2047 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2048 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2049 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2050 uuid_str1, uuid_str2, uuid_str3);
2051 CHECK_OAL_GATT_ENABLED();
2052 CHECK_CLIENT_CONNECTION(conn_id);
2054 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2055 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2056 if (ret != BT_STATUS_SUCCESS) {
2057 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2058 return convert_to_oal_status(ret);
2061 return OAL_STATUS_SUCCESS;
2064 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2065 oal_gatt_id_t *char_id, int *fd, int *mtu)
2067 int ret = OAL_STATUS_SUCCESS;
2068 char uuid_str1[2*BT_UUID_STRING_MAX];
2069 char uuid_str2[2*BT_UUID_STRING_MAX];
2070 OAL_CHECK_PARAMETER(srvc_id, return);
2071 OAL_CHECK_PARAMETER(char_id, return);
2072 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2073 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2074 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2075 CHECK_OAL_GATT_ENABLED();
2076 CHECK_CLIENT_CONNECTION(conn_id);
2078 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2079 (btgatt_gatt_id_t *)char_id, fd, mtu);
2080 if (ret != BT_STATUS_SUCCESS) {
2081 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2082 return convert_to_oal_status(ret);
2085 return OAL_STATUS_SUCCESS;
2088 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2089 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2091 int ret = OAL_STATUS_SUCCESS;
2092 char uuid_str1[2*BT_UUID_STRING_MAX];
2093 char uuid_str2[2*BT_UUID_STRING_MAX];
2094 OAL_CHECK_PARAMETER(srvc_id, return);
2095 OAL_CHECK_PARAMETER(char_id, return);
2096 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2097 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2098 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2099 CHECK_OAL_GATT_ENABLED();
2100 CHECK_CLIENT_CONNECTION(conn_id);
2102 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2103 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2104 if (ret != BT_STATUS_SUCCESS) {
2105 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2106 return convert_to_oal_status(ret);
2109 return OAL_STATUS_SUCCESS;
2112 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2113 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2114 int len, oal_gatt_auth_req_t auth_req, char* data)
2116 int ret = OAL_STATUS_SUCCESS;
2117 char uuid_str1[2*BT_UUID_STRING_MAX];
2118 char uuid_str2[2*BT_UUID_STRING_MAX];
2119 OAL_CHECK_PARAMETER(srvc_id, return);
2120 OAL_CHECK_PARAMETER(char_id, return);
2121 OAL_CHECK_PARAMETER(data, return);
2122 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2123 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2124 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2125 CHECK_OAL_GATT_ENABLED();
2126 CHECK_CLIENT_CONNECTION(conn_id);
2128 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2129 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2130 if (ret != BT_STATUS_SUCCESS) {
2131 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2132 return convert_to_oal_status(ret);
2135 return OAL_STATUS_SUCCESS;
2138 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2139 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2140 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2142 int ret = OAL_STATUS_SUCCESS;
2143 char uuid_str1[2*BT_UUID_STRING_MAX];
2144 char uuid_str2[2*BT_UUID_STRING_MAX];
2145 char uuid_str3[2*BT_UUID_STRING_MAX];
2146 OAL_CHECK_PARAMETER(srvc_id, return);
2147 OAL_CHECK_PARAMETER(char_id, return);
2148 OAL_CHECK_PARAMETER(desc_id, return);
2149 OAL_CHECK_PARAMETER(data, return);
2150 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2151 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2152 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2153 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2154 uuid_str1, uuid_str2, uuid_str3);
2155 CHECK_OAL_GATT_ENABLED();
2156 CHECK_CLIENT_CONNECTION(conn_id);
2158 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2159 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2160 if (ret != BT_STATUS_SUCCESS) {
2161 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2162 return convert_to_oal_status(ret);
2165 return OAL_STATUS_SUCCESS;
2168 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2173 OAL_CHECK_PARAMETER(address, return);
2174 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2175 CHECK_OAL_GATT_ENABLED();
2177 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2178 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2179 if (ret != BT_STATUS_SUCCESS) {
2180 BT_ERR("error: %s", status2string(ret));
2181 return convert_to_oal_status(ret);
2183 return OAL_STATUS_SUCCESS;
2186 oal_status_t gattc_unregister_scan_filter(int slot_id)
2192 CHECK_OAL_GATT_ENABLED();
2194 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2196 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2197 if (ret != BT_STATUS_SUCCESS) {
2198 BT_ERR("error: %s", status2string(ret));
2199 return convert_to_oal_status(ret);
2201 return OAL_STATUS_SUCCESS;
2204 oal_status_t gattc_enable_scan_filter(int client_if)
2209 CHECK_OAL_GATT_ENABLED();
2211 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2213 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2214 if (ret != BT_STATUS_SUCCESS) {
2215 BT_ERR("error: %s", status2string(ret));
2216 return convert_to_oal_status(ret);
2218 return OAL_STATUS_SUCCESS;
2221 oal_status_t gattc_disable_scan_filter(int client_if)
2226 CHECK_OAL_GATT_ENABLED();
2228 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2230 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2231 if (ret != BT_STATUS_SUCCESS) {
2232 BT_ERR("error: %s", status2string(ret));
2233 return convert_to_oal_status(ret);
2235 return OAL_STATUS_SUCCESS;
2238 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2241 int client_info = 0;
2244 int company_id_mask = 0;
2245 int address_type = 0;
2246 int feature_selection = 0;
2248 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2249 .filt_logic_type = 1,
2250 .rssi_high_thres = -127,
2251 .rssi_low_thres = -127,
2255 .found_timeout_cnt = 0
2258 OAL_CHECK_PARAMETER(filter_data, return);
2260 CHECK_OAL_GATT_ENABLED();
2262 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2264 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2265 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2266 ret = gatt_api->client->scan_filter_add_remove(client_info,
2268 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2269 filter_data->slot_id,
2274 (bt_bdaddr_t*)filter_data->device_address,
2281 if (ret != BT_STATUS_SUCCESS){
2282 BT_ERR("error: %s", status2string(ret));
2283 BT_INFO("unregistering already set filter features.");
2284 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2285 return convert_to_oal_status(ret);
2288 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2290 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2291 ret = gatt_api->client->scan_filter_add_remove(client_info,
2293 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2294 filter_data->slot_id,
2302 filter_data->device_name, // device_name as p_data in HAL
2306 if (ret != BT_STATUS_SUCCESS){
2307 BT_ERR("error: %s", status2string(ret));
2308 BT_INFO("unregistering already set filter features.");
2309 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2310 return convert_to_oal_status(ret);
2313 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2315 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2316 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2317 char uuid_str1[2*BT_UUID_STRING_MAX];
2318 char uuid_str2[2*BT_UUID_STRING_MAX];
2320 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2321 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2323 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2324 ret = gatt_api->client->scan_filter_add_remove(client_info,
2326 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2327 filter_data->slot_id,
2330 (bt_uuid_t*)filter_data->service_uuid,
2331 (bt_uuid_t*)filter_data->service_uuid_mask,
2334 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2336 filter_data->service_uuid_mask_len,
2339 if (ret != BT_STATUS_SUCCESS){
2340 BT_ERR("error: %s", status2string(ret));
2341 BT_INFO("unregistering already set filter features.");
2342 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2343 return convert_to_oal_status(ret);
2346 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2348 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2349 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2350 char uuid_str1[2*BT_UUID_STRING_MAX];
2351 char uuid_str2[2*BT_UUID_STRING_MAX];
2352 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2353 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2354 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2355 ret = gatt_api->client->scan_filter_add_remove(client_info,
2357 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2358 filter_data->slot_id,
2361 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2362 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2365 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2367 filter_data->service_solicitation_uuid_mask_len,
2370 if (ret != BT_STATUS_SUCCESS){
2371 BT_ERR("error: %s", status2string(ret));
2372 BT_INFO("unregistering already set filter features.");
2373 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2374 return convert_to_oal_status(ret);
2377 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2379 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2380 ret = gatt_api->client->scan_filter_add_remove(client_info,
2382 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2383 filter_data->slot_id,
2390 filter_data->service_data_len, //service_data_len as data_len in HAL
2391 (char*)filter_data->service_data,
2392 filter_data->service_data_mask_len,
2393 (char*)filter_data->service_data_mask
2395 if (ret != BT_STATUS_SUCCESS){
2396 BT_ERR("error: %s", status2string(ret));
2397 BT_INFO("unregistering already set filter features.");
2398 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2399 return convert_to_oal_status(ret);
2402 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2404 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2405 ret = gatt_api->client->scan_filter_add_remove(client_info,
2407 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2408 filter_data->slot_id,
2409 filter_data->manufacturer_id,
2415 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2416 (char*)filter_data->manufacturer_data,
2417 filter_data->manufacturer_data_mask_len,
2418 (char*)filter_data->manufacturer_data_mask
2420 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2421 if (ret != BT_STATUS_SUCCESS){
2422 BT_ERR("error: %s", status2string(ret));
2423 BT_INFO("unregistering already set filter features.");
2424 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2425 return convert_to_oal_status(ret);
2428 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2431 BT_DBG("Filter selection 0x%.2x", feature_selection);
2433 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2434 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2435 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2436 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2437 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2438 if (ret != BT_STATUS_SUCCESS){
2439 BT_ERR("error: %s", status2string(ret));
2440 return convert_to_oal_status(ret);
2442 return OAL_STATUS_SUCCESS;
2445 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2449 API_TRACE("Configure MTU Size: [%d]", mtu);
2450 CHECK_OAL_GATT_ENABLED();
2451 CHECK_CLIENT_CONNECTION(conn_id);
2453 /* To prevent crash in case other libraries not support this api */
2454 if (gatt_api->client->configure_mtu == NULL) {
2455 BT_WARN("configure_mtu is NULL");
2456 return OAL_STATUS_NOT_SUPPORT;
2459 ret = gatt_api->client->configure_mtu(conn_id, mtu);
2460 if (ret != BT_STATUS_SUCCESS) {
2461 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2462 return convert_to_oal_status(ret);
2464 return OAL_STATUS_SUCCESS;
2467 oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int server_inst_id)
2469 int ret = OAL_STATUS_SUCCESS;
2472 OAL_CHECK_PARAMETER(device_address, return);
2473 API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
2474 CHECK_OAL_GATT_ENABLED();
2475 CHECK_SERVER_INSTANCE(server_inst_id);
2476 CHECK_SERVER_REGISTRATION(server_inst_id);
2478 ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, server_inst_id);
2479 if (ret != BT_STATUS_SUCCESS) {
2480 BT_ERR("GATT connection info add failed: %s", status2string(ret));
2481 return convert_to_oal_status(ret);
2483 return OAL_STATUS_SUCCESS;