2 * Open Adaptation Layer (OAL)
4 * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <bluetooth.h>
22 #include "oal-event.h"
23 #include "oal-internal.h"
24 #include "oal-manager.h"
25 #include "oal-adapter-mgr.h"
26 #include "oal-utils.h"
28 #include "oal-common.h"
30 #define DEV_APPEARANCE 0x0000
31 #define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
32 #define MAX_PROP_LEN 95 /* SVACE WGID: 324403*/
33 #define MAX_PERM_LEN 80 //Fix for svace wgid:324402
35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
36 #define CHECK_OAL_GATT_ENABLED() \
38 if (gatt_api == NULL) { \
39 BT_ERR("GATT Not Enabled"); \
40 return OAL_STATUS_NOT_READY; \
44 #define CHECK_SERVER_INSTANCE(instance_id) \
46 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
47 BT_ERR("Invalid Instance"); \
48 return OAL_STATUS_INVALID_PARAM; \
52 #define CHECK_SERVER_REGISTRATION(instance_id) \
54 if (gatt_servers[instance_id - 1].server_id < 0) {\
55 BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
56 return OAL_STATUS_INTERNAL_ERROR;\
60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
62 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
63 if (gatt_servers[instance_id - 1].server_id == server_if) { \
64 server_inst = instance_id; \
70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
72 char * buf_str = g_malloc0(3*length + 1);\
73 if (NULL != buf_str) { \
74 convert_hex_2_str(manuf_data, length, buf_str);\
75 if (TRUE == data_type) \
76 BT_INFO("Scan Response Data:%s\n", buf_str);\
78 BT_INFO("Advertising Data:%s\n", buf_str);\
83 #define CHECK_CLIENT_REGISTRATION(client_id) \
85 if (client_id <= 0) { \
86 BT_DBG("No client registered yet...");\
87 return OAL_STATUS_INTERNAL_ERROR;\
91 #define CHECK_CLIENT_CONNECTION(conn_id) \
94 BT_ERR("No active connection");\
95 return OAL_STATUS_INTERNAL_ERROR;\
102 GATT_INS_DATA_SETTING,
114 const char *oal_device_type[] = {
125 } oal_pending_gattc_req_e;
127 static const btgatt_interface_t * gatt_api;
128 static gboolean cur_adv_state[NUM_SERVER_INST];
129 static gatt_server_t gatt_servers[NUM_SERVER_INST];
131 /* Forward declarations of GATT Server callbacks */
132 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
133 static void cb_gatts_multi_adv_enable(int server_if, int status);
134 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status);
135 static void cb_gatts_multi_adv_disable(int server_if, int status);
136 static void cb_gatts_multi_adv_update(int server_if, int status);
138 static void cb_gatts_listen(int status, int server_if);
141 static void cb_gatts_service_added(int status, int server_if, btgatt_srvc_id_t *srvc_id, int srvc_handle);
142 static void cb_gatts_included_service_added(int status, int server_if, int srvc_handle, int incl_srvc_handle);
143 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id, int srvc_handle, int char_handle);
144 static void cb_gatts_descriptor_added(int status, int server_if, bt_uuid_t *descr_id, int srvc_handle, int descr_handle);
146 static void cb_gatts_service_started(int status, int server_if, int srvc_handle);
147 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle);
148 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle);
150 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, bool is_long);
151 static void cb_gatts_request_write(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, int length,
152 bool need_rsp, bool is_prep, uint8_t* value);
153 static void cb_gatts_response_confirmation(int status, int handle);
155 static void cb_gatts_acquire_write(int fd, int conn_id, int trans_id, int attr_handle, bt_bdaddr_t*);
156 static void cb_gatts_acquire_notify(int fd, int conn_id, int trans_id, int attr_handle);
158 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
159 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
161 static void cb_gatts_mtu_changed(int conn_id, int mtu);
164 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda);
167 /************************************HAL Interface *************************************/
169 /*TODO GATT Server callbacks will be implemented in subsequent patches */
170 static const btgatt_server_callbacks_t btgatt_server_callbacks = {
171 .register_server_cb = cb_gatts_register_app,
172 .connection_cb = cb_gatts_connection,
173 .service_added_cb = cb_gatts_service_added,
174 .included_service_added_cb = cb_gatts_included_service_added,
175 .characteristic_added_cb = cb_gatts_characteristic_added,
176 .descriptor_added_cb = cb_gatts_descriptor_added,
177 .service_started_cb = cb_gatts_service_started,
178 .service_stopped_cb = cb_gatts_service_stopped,
179 .service_deleted_cb = cb_gatts_service_deleted,
180 .indication_confirmation_cb = cb_indication_confirmation,
181 .request_read_cb = cb_gatts_request_read,
182 .request_write_cb = cb_gatts_request_write,
183 .request_exec_write_cb = NULL,
184 .response_confirmation_cb = cb_gatts_response_confirmation,
185 .listen_cb = cb_gatts_listen,
186 .multi_adv_enable_cb = cb_gatts_multi_adv_enable,
187 .multi_adv_update_cb = cb_gatts_multi_adv_update,
188 .multi_adv_data_cb = cb_gatts_multi_adv_set_inst_data,
189 .multi_adv_disable_cb = cb_gatts_multi_adv_disable,
190 .mtu_changed_cb = cb_gatts_mtu_changed,
192 .notif_enabled_cb = cb_notifcation_changed,
194 .request_acquire_write_cb = cb_gatts_acquire_write,
195 .request_acquire_notify_cb = cb_gatts_acquire_notify
198 /* Forward declaration for GATT client callbacks */
199 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
200 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
201 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
202 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
203 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
204 static void cb_gattc_search_complete(int conn_id, int status);
205 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
206 btgatt_gatt_id_t *char_id, int char_prop);
207 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
208 btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
209 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
210 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
211 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
212 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
213 static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
214 btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
215 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
217 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
218 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
219 .register_client_cb = cb_gattc_register_app,
220 .scan_result_cb = cb_gattc_scan_result,
221 .open_cb = cb_gattc_connection,
222 .close_cb = cb_gattc_disconnect,
223 .search_complete_cb = cb_gattc_search_complete,
224 .search_result_cb = cb_gattc_search_result,
225 .get_characteristic_cb = cb_gattc_get_characteristics,
226 .get_descriptor_cb = cb_gattc_get_descriptor,
227 .get_included_service_cb = NULL,
228 .register_for_notification_cb = cb_gattc_register_for_notification,
229 .notify_cb = cb_gattc_notify,
230 .read_characteristic_cb = cb_gattc_read_characteristic,
231 .write_characteristic_cb = cb_gattc_write_characteristic,
232 .read_descriptor_cb = cb_gattc_read_descriptor,
233 .write_descriptor_cb = cb_gattc_write_descriptor,
234 .execute_write_cb = NULL,
235 .read_remote_rssi_cb = NULL,
236 .configure_mtu_cb = NULL,
237 #ifdef PLATFORM_ANDROID_HAL
238 .scan_filter_cfg_cb = NULL,
239 .scan_filter_param_cb = NULL,
240 .scan_filter_status_cb = NULL,
241 .congestion_cb = NULL,
242 .batchscan_cfg_storage_cb = NULL,
243 .batchscan_enb_disable_cb = NULL,
244 .batchscan_reports_cb = NULL,
245 .batchscan_threshold_cb = NULL,
246 .track_adv_event_cb = NULL,
250 static btgatt_callbacks_t btgatt_callbacks = {
251 sizeof(btgatt_callbacks_t),
252 &btgatt_client_callbacks,
253 &btgatt_server_callbacks
256 /*******************************GATT Initialisation - Deinitialisation********************************/
257 oal_status_t gatt_enable(void)
259 const bt_interface_t * blued_api;
263 for (i = 0; i < NUM_SERVER_INST; i++) {
264 gatt_servers[i].server_id = -1;
265 gatt_servers[i].state = GATT_INS_DISABLED;
266 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
267 cur_adv_state[i] = FALSE;
270 /* Get stack interface */
271 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
273 if (blued_api == NULL) {
274 BT_ERR("Stack is not initialized");
275 return OAL_STATUS_NOT_READY;
279 BT_WARN("GATT Interface is already initialized...");
280 return OAL_STATUS_ALREADY_DONE;
283 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
284 if (gatt_api == NULL) {
285 BT_ERR("GATT interface failed");
286 return OAL_STATUS_INTERNAL_ERROR;
289 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
290 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
293 return convert_to_oal_status(ret);
296 BT_INFO("GATT successfully initialized");
297 return OAL_STATUS_SUCCESS;
300 oal_status_t gatt_disable(void)
308 for (i = 0; i < NUM_SERVER_INST; i++) {
309 gatt_servers[i].server_id = -1;
310 gatt_servers[i].state = GATT_INS_DISABLED;
311 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
313 return OAL_STATUS_SUCCESS;
316 /************************************GATT Server Functions*************************************/
318 oal_status_t gatts_register(oal_uuid_t* server_uuid)
320 char str[2*BT_UUID_STRING_MAX];
321 int ret = OAL_STATUS_SUCCESS;
324 CHECK_OAL_GATT_ENABLED();
325 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
326 API_TRACE("Register the server instance: UUID: [%s]", str);
328 for (i = 0; i < NUM_SERVER_INST; i++) {
329 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
330 if (gatt_servers[i].server_id != -1) {
331 BT_ERR("This is resevered UUID for easy set up application i = %d \
332 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
333 return OAL_STATUS_ALREADY_DONE;
338 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
340 if (ret != BT_STATUS_SUCCESS) {
341 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
342 return convert_to_oal_status(ret);
344 return OAL_STATUS_SUCCESS;
347 oal_status_t gatts_unregister(int instance_id)
349 int ret = OAL_STATUS_SUCCESS;
350 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
352 CHECK_OAL_GATT_ENABLED();
353 CHECK_SERVER_INSTANCE(instance_id);
354 CHECK_SERVER_REGISTRATION(instance_id);
356 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
358 if (ret != BT_STATUS_SUCCESS) {
359 BT_ERR("GATT server unregistration failed: %d", instance_id);
360 return convert_to_oal_status(ret);
363 gatt_servers[instance_id-1].server_id = -1;
364 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
366 if (instance_id != 1 && instance_id != 2)
367 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
369 return OAL_STATUS_SUCCESS;
372 /* Legacy Advertisement */
373 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
375 int ret = OAL_STATUS_SUCCESS;
376 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
378 CHECK_OAL_GATT_ENABLED();
379 CHECK_SERVER_INSTANCE(instance_id);
380 CHECK_SERVER_REGISTRATION(instance_id);
382 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
384 if (ret != BT_STATUS_SUCCESS) {
385 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
386 gatt_servers[instance_id-1].server_id, status2string(ret));
387 return convert_to_oal_status(ret);
390 return OAL_STATUS_SUCCESS;
393 oal_status_t gatts_stop_advertising(int instance_id)
395 int ret = OAL_STATUS_SUCCESS;
396 API_TRACE("Stop advertising");
398 CHECK_OAL_GATT_ENABLED();
399 CHECK_SERVER_INSTANCE(instance_id);
400 CHECK_SERVER_REGISTRATION(instance_id);
402 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
404 if (ret != BT_STATUS_SUCCESS) {
405 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
406 instance_id, status2string(ret));
407 return convert_to_oal_status(ret);
409 return OAL_STATUS_SUCCESS;
413 /* Below API's need to be removed as they are hardcoded API's.
414 If at all, product specific API's are required to set specific data, then new naming should
415 be adopted for these API's */
416 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
418 int ret = OAL_STATUS_SUCCESS;
420 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
421 CHECK_OAL_GATT_ENABLED();
422 CHECK_SERVER_INSTANCE(instance_id);
423 CHECK_SERVER_REGISTRATION(instance_id);
425 /* Historically used for Legacy Advertising */
426 return OAL_STATUS_NOT_SUPPORT;
429 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
431 int ret = OAL_STATUS_SUCCESS;
433 API_TRACE("Set advertising data");
434 CHECK_OAL_GATT_ENABLED();
435 CHECK_SERVER_INSTANCE(instance_id);
436 CHECK_SERVER_REGISTRATION(instance_id);
438 /* Historically used for Legacy Advertising */
439 return OAL_STATUS_NOT_SUPPORT;
442 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
444 int ret = OAL_STATUS_SUCCESS;
446 API_TRACE("Set Scan Response data");
447 CHECK_OAL_GATT_ENABLED();
448 CHECK_SERVER_INSTANCE(instance_id);
449 CHECK_SERVER_REGISTRATION(instance_id);
451 /* Historically used for Legacy Advertising */
452 return OAL_STATUS_NOT_SUPPORT;
456 oal_status_t gatts_multi_adv_enable(int instance_id)
458 int ret = OAL_STATUS_SUCCESS;
459 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
460 gatt_servers[instance_id - 1].server_id, instance_id);
462 CHECK_OAL_GATT_ENABLED();
463 CHECK_SERVER_INSTANCE(instance_id);
464 CHECK_SERVER_REGISTRATION(instance_id);
466 if (gatt_api->server->multi_adv_enable == NULL)
467 return OAL_STATUS_NOT_SUPPORT;
469 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
470 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
471 BT_ERR("Not allowed, state: %d, instance_id: %d",
472 gatt_servers[instance_id - 1].state, instance_id);
473 return OAL_STATUS_BUSY;
476 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
477 BT_ERR("Not allowed, state: %d, instance_id: %d",
478 gatt_servers[instance_id - 1].state, instance_id);
479 return OAL_STATUS_ALREADY_DONE;
482 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
483 BT_ERR("Not allowed, state: %d, instance_id: %d",
484 gatt_servers[instance_id - 1].state, instance_id);
485 return OAL_STATUS_BUSY;
488 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
490 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
492 if (ret != BT_STATUS_SUCCESS) {
493 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
494 instance_id, status2string(ret));
495 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
496 return convert_to_oal_status(ret);
498 return OAL_STATUS_SUCCESS;
501 oal_status_t gatts_multi_adv_disable(int instance_id)
503 int ret = OAL_STATUS_SUCCESS;
504 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
505 gatt_servers[instance_id - 1].server_id, instance_id);
507 CHECK_OAL_GATT_ENABLED();
508 CHECK_SERVER_INSTANCE(instance_id);
509 CHECK_SERVER_REGISTRATION(instance_id);
511 if (gatt_api->server->multi_adv_disable == NULL)
512 return OAL_STATUS_NOT_SUPPORT;
514 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
515 BT_ERR("Not Allowed, state: %d, instance_id: %d",
516 gatt_servers[instance_id - 1].state, instance_id);
517 return OAL_STATUS_BUSY;
520 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
522 if (ret != BT_STATUS_SUCCESS) {
523 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
524 instance_id, status2string(ret));
525 return convert_to_oal_status(ret);
527 return OAL_STATUS_SUCCESS;
530 oal_status_t gatts_multi_adv_update(int instance_id,
531 int min_intv, int max_intv,
532 int adv_type, int chnl_map,
533 int tx_power, int timeout_s)
535 int ret = OAL_STATUS_SUCCESS;
536 API_TRACE("Multi advertising Update");
538 CHECK_OAL_GATT_ENABLED();
539 CHECK_SERVER_INSTANCE(instance_id);
540 CHECK_SERVER_REGISTRATION(instance_id);
542 if (gatt_api->server->multi_adv_update == NULL)
543 return OAL_STATUS_NOT_SUPPORT;
545 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
548 tx_power, timeout_s);
550 if (ret != BT_STATUS_SUCCESS) {
551 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
552 instance_id, status2string(ret));
553 return convert_to_oal_status(ret);
555 return OAL_STATUS_SUCCESS;
558 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
559 oal_ble_multi_adv_param_setup_t *adv_param_setup)
561 int ret = OAL_STATUS_SUCCESS;
562 btgatt_adv_param_setup_t adv_setup;
563 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
564 gatt_servers[instance_id - 1].server_id, instance_id);
566 CHECK_OAL_GATT_ENABLED();
567 CHECK_SERVER_INSTANCE(instance_id);
568 CHECK_SERVER_REGISTRATION(instance_id);
570 if (gatt_api->server->multi_adv_set_inst_data == NULL)
571 return OAL_STATUS_NOT_SUPPORT;
573 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
574 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
575 return OAL_STATUS_BUSY;
578 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
581 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
582 adv_setup.include_name = adv_param_setup->include_name;
583 adv_setup.include_txpower = adv_param_setup->include_txpower;
584 adv_setup.appearance = adv_param_setup->appearance;
585 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
586 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
587 adv_setup.service_data = adv_param_setup->service_data;
588 adv_setup.service_data_len = adv_param_setup->service_data_len;
589 adv_setup.service_uuid = adv_param_setup->service_uuid;
590 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
591 /* Solicit UUID handler: Start */
592 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
593 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
594 /* Solicit UUID handler: End */
595 adv_setup.min_interval = adv_param_setup->min_interval;
596 adv_setup.max_interval = adv_param_setup->min_interval;
597 adv_setup.adv_type = adv_param_setup->adv_type;
598 adv_setup.chnl_map = adv_param_setup->chnl_map;
599 adv_setup.tx_power = adv_param_setup->tx_power;
600 adv_setup.timeout_s = adv_param_setup->timeout_s;
602 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
603 if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
604 BT_INFO("Manufacture data.....\n");
605 PRINT_ADV_DATA(adv_setup.manufacturer_data_len, (unsigned char *)adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
608 if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
609 BT_INFO("Service uuid.....\n");
610 PRINT_ADV_DATA(adv_setup.service_uuid_len, (unsigned char*)adv_setup.service_uuid, FALSE);
614 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
616 if (ret != BT_STATUS_SUCCESS) {
617 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
618 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
619 return convert_to_oal_status(ret);
621 return OAL_STATUS_SUCCESS;
624 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
626 int ret = OAL_STATUS_SUCCESS;
629 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
631 CHECK_OAL_GATT_ENABLED();
632 CHECK_SERVER_INSTANCE(instance_id);
633 CHECK_SERVER_REGISTRATION(instance_id);
635 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
637 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
638 if (ret != BT_STATUS_SUCCESS) {
639 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
640 return convert_to_oal_status(ret);
642 return OAL_STATUS_SUCCESS;
646 /************************************GATT Server Functions*************************************/
648 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
651 char str[2*BT_UUID_STRING_MAX];
652 uuid_to_stringname((service_uuid_t*)uuid, str);
654 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
656 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
657 BT_INFO("UUID: [%s]", str);
659 for (i = 0; i < NUM_SERVER_INST; i++) {
660 if (gatt_servers[i].server_id == -1) {
661 BT_INFO("Server Instance registered with stack [%d]", i+1);
662 gatt_servers[i].server_id = server_if;
663 event->server_inst = i+1;
664 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
665 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
669 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
672 static void cb_gatts_listen(int status, int server_if)
674 gboolean prev_state[NUM_SERVER_INST];
676 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
679 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
680 if (gatt_servers[instance_id - 1].server_id == server_if) {
681 event->server_inst = instance_id;
684 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
687 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
688 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
689 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
690 cur_adv_state[event->server_inst - 1] = new_state;
692 BT_ERR("Invalid Callback...");
697 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
699 if (TRUE == new_state)
700 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
702 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
705 static void cb_gatts_multi_adv_enable(int server_if, int status)
708 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
709 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
712 if (status != BT_STATUS_SUCCESS)
713 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
715 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
716 if (gatt_servers[instance_id - 1].server_id == server_if) {
717 event->server_inst = instance_id;
718 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
722 BT_ERR("Invalid Interface, srv_if: %d", server_if);
723 event->server_inst = -1;
725 event->status = convert_to_oal_status(status);
726 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
729 static void cb_gatts_multi_adv_disable(int server_if, int status)
731 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
732 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
735 if (status != BT_STATUS_SUCCESS)
736 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
738 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
739 if (gatt_servers[instance_id - 1].server_id == server_if) {
740 event->server_inst = instance_id;
741 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
745 BT_ERR("Invalid Interface, srv_if: %d", server_if);
746 event->server_inst = -1;
748 event->status = convert_to_oal_status(status);
749 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
752 static void cb_gatts_multi_adv_update(int server_if, int status)
754 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
755 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
758 if (status != BT_STATUS_SUCCESS)
759 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
761 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
762 if (gatt_servers[instance_id - 1].server_id == server_if) {
763 event->server_inst = instance_id;
767 BT_ERR("Invalid Interface, srv_if: %d", server_if);
768 event->server_inst = -1;
770 event->status = convert_to_oal_status(status);
771 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
774 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
776 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
777 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
780 if (status != BT_STATUS_SUCCESS)
781 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
783 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
784 if (gatt_servers[instance_id - 1].server_id == server_if) {
785 event->server_inst = instance_id;
786 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
790 BT_ERR("Invalid Interface, srv_if: %d", server_if);
791 event->server_inst = -1;
793 event->status = convert_to_oal_status(status);
794 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
797 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
799 int ret = OAL_STATUS_SUCCESS;
800 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
801 CHECK_OAL_GATT_ENABLED();
802 OAL_CHECK_PARAMETER(mtu, return);
804 /* To prevent crash in case other libraries not support this api */
805 if (gatt_api->server->get_att_mtu == NULL) {
806 BT_WARN("get_att_mtu is NULL");
807 return OAL_STATUS_NOT_SUPPORT;
810 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
811 if (ret != BT_STATUS_SUCCESS) {
812 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
813 return convert_to_oal_status(ret);
816 BT_INFO("Current ATT MTU Size: %d", *mtu);
817 return OAL_STATUS_SUCCESS;
819 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
820 int status, int fd, int mtu , void * fdlist)
822 int ret = OAL_STATUS_SUCCESS;
824 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
825 CHECK_OAL_GATT_ENABLED();
827 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
828 if (ret != BT_STATUS_SUCCESS) {
829 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
830 return convert_to_oal_status(ret);
832 return OAL_STATUS_SUCCESS;
835 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
838 int ret = OAL_STATUS_SUCCESS;
839 btgatt_srvc_id_t btgatt_srvc_id;
840 char str[2*BT_UUID_STRING_MAX];
842 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
843 CHECK_OAL_GATT_ENABLED();
845 CHECK_SERVER_INSTANCE(instance_id);
846 CHECK_SERVER_REGISTRATION(instance_id);
848 if (gatt_serv_id != NULL) {
849 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
850 API_TRACE("Service uuid: [%s]", str);
851 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
852 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
853 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
855 BT_INFO("GATT Server Service Id is NULL");
856 return OAL_STATUS_INVALID_PARAM;
859 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
861 if (ret != BT_STATUS_SUCCESS) {
862 BT_ERR("GATT Server add service failed: %s", status2string(ret));
863 return convert_to_oal_status(ret);
865 return OAL_STATUS_SUCCESS;
868 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
871 int ret = OAL_STATUS_SUCCESS;
872 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
873 instance_id, serv_handle, incl_handle);
874 CHECK_OAL_GATT_ENABLED();
876 CHECK_SERVER_INSTANCE(instance_id);
878 CHECK_SERVER_REGISTRATION(instance_id);
880 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
881 if (ret != BT_STATUS_SUCCESS) {
882 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
883 return convert_to_oal_status(ret);
885 return OAL_STATUS_SUCCESS;
888 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
889 oal_uuid_t* charc_uuid, int propts, int permsn)
891 int ret = OAL_STATUS_SUCCESS;
892 char str[2*BT_UUID_STRING_MAX];
893 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
894 char_prop_to_string(propts, prop);
895 char_perm_to_string(permsn, perm);
896 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
897 instance_id, serv_handle, prop, perm);
898 CHECK_OAL_GATT_ENABLED();
900 CHECK_SERVER_INSTANCE(instance_id);
902 CHECK_SERVER_REGISTRATION(instance_id);
904 if (charc_uuid != NULL) {
905 uuid_to_stringname(charc_uuid, str);
906 API_TRACE("uuid: [%s]", str);
909 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
910 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
911 if (ret != BT_STATUS_SUCCESS) {
912 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
913 return convert_to_oal_status(ret);
915 return OAL_STATUS_SUCCESS;
918 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
919 oal_uuid_t* desc_uuid, int permsn)
921 int ret = OAL_STATUS_SUCCESS;
922 char str[2*BT_UUID_STRING_MAX];
923 char perm[MAX_PERM_LEN];
924 char_perm_to_string(permsn, perm);
925 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
926 instance_id, serv_handle, perm);
927 CHECK_OAL_GATT_ENABLED();
929 CHECK_SERVER_INSTANCE(instance_id);
931 CHECK_SERVER_REGISTRATION(instance_id);
933 if (desc_uuid != NULL) {
934 uuid_to_stringname(desc_uuid, str);
935 API_TRACE("uuid: [%s]", str);
938 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
939 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
941 if (ret != BT_STATUS_SUCCESS) {
942 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
943 return convert_to_oal_status(ret);
945 return OAL_STATUS_SUCCESS;
948 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
950 int ret = OAL_STATUS_SUCCESS;
952 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
953 instance_id, svc_handle, transport);
954 CHECK_OAL_GATT_ENABLED();
956 CHECK_SERVER_INSTANCE(instance_id);
958 CHECK_SERVER_REGISTRATION(instance_id);
960 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
962 if (ret != BT_STATUS_SUCCESS) {
963 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
964 return convert_to_oal_status(ret);
966 return OAL_STATUS_SUCCESS;
969 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
971 int ret = OAL_STATUS_SUCCESS;
973 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
974 CHECK_OAL_GATT_ENABLED();
976 CHECK_SERVER_INSTANCE(ins_id);
977 CHECK_SERVER_REGISTRATION(ins_id);
979 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
980 if (ret != BT_STATUS_SUCCESS) {
981 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
982 return convert_to_oal_status(ret);
984 return OAL_STATUS_SUCCESS;
987 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
989 int ret = OAL_STATUS_SUCCESS;
991 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
992 CHECK_OAL_GATT_ENABLED();
994 CHECK_SERVER_INSTANCE(ins_id);
996 CHECK_SERVER_REGISTRATION(ins_id);
998 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
999 if (ret != BT_STATUS_SUCCESS) {
1000 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1001 return convert_to_oal_status(ret);
1003 return OAL_STATUS_SUCCESS;
1006 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1008 int ret = OAL_STATUS_SUCCESS;
1010 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1011 CHECK_OAL_GATT_ENABLED();
1013 if (response == NULL) {
1014 BT_ERR("GATT Server attribute value is empty");
1015 return OAL_STATUS_INVALID_PARAM;
1018 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1019 if (ret != BT_STATUS_SUCCESS) {
1020 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1021 return convert_to_oal_status(ret);
1023 return OAL_STATUS_SUCCESS;
1026 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1028 int ret = OAL_STATUS_SUCCESS;
1030 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1031 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1032 CHECK_OAL_GATT_ENABLED();
1034 CHECK_SERVER_INSTANCE(ins_id);
1036 CHECK_SERVER_REGISTRATION(ins_id);
1038 if (value == NULL || len == 0) {
1039 BT_ERR("GATT Server attribute value is empty");
1040 return OAL_STATUS_INVALID_PARAM;
1043 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1044 attr_hndl, conn_id, len, confirm, value);
1046 if (ret != BT_STATUS_SUCCESS) {
1047 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1048 return convert_to_oal_status(ret);
1050 return OAL_STATUS_SUCCESS;
1053 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1055 int ret = OAL_STATUS_SUCCESS;
1057 CHECK_OAL_GATT_ENABLED();
1059 CHECK_SERVER_INSTANCE(ins_id);
1061 CHECK_SERVER_REGISTRATION(ins_id);
1063 if (value == NULL || value->len == 0) {
1064 BT_ERR("GATT Server attribute value is empty");
1065 return OAL_STATUS_INVALID_PARAM;
1068 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1069 ins_id, value->handle, value->len);
1071 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1072 (int)value->handle, (int)value->len, (char*)value->value);
1074 if (ret != BT_STATUS_SUCCESS) {
1075 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1076 return convert_to_oal_status(ret);
1078 return OAL_STATUS_SUCCESS;
1081 /* GATT Server Callbacks:Start */
1082 static void cb_gatts_service_added(int status, int server_if,
1083 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1087 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1088 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1090 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1092 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1093 event->gatt_srvc_stat.server_inst = -1;
1095 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1096 if (psrvc_id != NULL) {
1097 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1098 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1099 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1100 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1103 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1105 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1108 static void cb_gatts_included_service_added(int status, int server_if,
1110 int incl_srvc_handle)
1113 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1114 status, srvc_handle, incl_srvc_handle);
1116 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1118 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1120 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1121 event->gatt_srvc_stat.server_inst = -1;
1123 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1124 event->incl_srvc_hndl = incl_srvc_handle;
1125 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1126 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1129 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1130 int srvc_handle, int char_handle)
1134 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1135 status, srvc_handle, char_handle);
1137 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1139 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1141 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1142 event->gatt_srvc_stat.server_inst = -1;
1144 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1145 event->charctr_hndl = char_handle;
1146 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1147 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1148 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1151 static void cb_gatts_descriptor_added(int status, int server_if,
1152 bt_uuid_t *descr_id, int srvc_handle,
1156 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1157 status, srvc_handle, descr_handle);
1159 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1161 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1163 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1164 event->gatt_srvc_stat.server_inst = -1;
1166 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1167 event->descrptr_hndl = descr_handle;
1168 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1169 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1170 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1173 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1176 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1178 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1180 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1182 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1183 event->server_inst = -1;
1185 event->servic_hndl = srvc_handle;
1186 event->status = convert_to_oal_status(status);
1187 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1190 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1193 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1195 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1197 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1199 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1200 event->server_inst = -1;
1202 event->servic_hndl = srvc_handle;
1203 event->status = convert_to_oal_status(status);
1204 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1207 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1210 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1212 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1214 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1216 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1217 event->server_inst = -1;
1219 event->servic_hndl = srvc_handle;
1220 event->status = convert_to_oal_status(status);
1221 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1224 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1227 oal_event_t event_type;
1229 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1230 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1232 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1233 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1234 event->server_inst = ins_id;
1237 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1240 if (ins_id == NUM_SERVER_INST+1) {
1241 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1245 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1246 event->conn_id = conn_id;
1247 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1248 event->status = OAL_STATUS_SUCCESS;
1250 send_event(event_type, event, sizeof(event_gatts_conn_t));
1253 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1254 int attr_handle, int offset, bool is_long)
1256 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1258 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1260 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1262 event->attr_trans.attr_handle = attr_handle;
1263 event->attr_trans.conn_id = conn_id;
1264 event->attr_trans.trans_id = trans_id;
1265 event->attr_trans.offset = offset;
1266 event->is_long = is_long;
1268 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1271 static void cb_gatts_request_write(int conn_id, int trans_id,
1272 bt_bdaddr_t *bda, int attr_handle,
1273 int offset, int length,
1274 bool need_rsp, bool is_prep, uint8_t* value)
1276 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1278 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1280 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1282 event->attr_trans.attr_handle = attr_handle;
1283 event->attr_trans.conn_id = conn_id;
1284 event->attr_trans.trans_id = trans_id;
1285 event->attr_trans.offset = offset;
1286 event->need_rsp = need_rsp;
1287 event->is_prep = is_prep;
1289 if (length > 0 && value != NULL) {
1290 if (length > OAL_GATT_MAX_ATTR_LEN)
1291 length = OAL_GATT_MAX_ATTR_LEN;
1292 memcpy(event->value, value, length);
1293 event->length = length;
1295 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1298 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1301 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1303 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1305 event->attr_trans.attr_handle = attr_handle;
1306 event->attr_trans.conn_id = conn_id;
1307 event->attr_trans.trans_id = trans_id;
1309 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1311 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1314 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1316 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1318 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1320 event->attr_trans.attr_handle = attr_handle;
1321 event->attr_trans.conn_id = conn_id;
1322 event->attr_trans.trans_id = trans_id;
1325 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1329 static void cb_gatts_response_confirmation(int status, int handle)
1331 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1333 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1335 event->hndl = handle;
1336 event->status = convert_to_oal_status(status);
1338 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1341 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1343 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1344 conn_id, trans_id, attr_handle);
1346 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1348 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1350 event->attr_handle = attr_handle;
1351 event->conn_id = conn_id;
1352 event->trans_id = trans_id;
1353 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1356 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1358 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1359 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1360 event->conn_id = conn_id;
1361 event->mtu_size = mtu;
1362 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1366 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1368 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1369 conn_id, trans_id, attr_handle, notify);
1371 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1373 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1375 event->attr_handle = attr_handle;
1376 event->conn_id = conn_id;
1377 event->trans_id = trans_id;
1378 event->notify = notify;
1379 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1384 /* GATT Server Callbacks: End */
1385 /************************************ GATT Client ***********************************/
1386 /* Client Callbacks */
1387 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1389 char uuid_str[BT_UUID_STRING_MAX];
1390 event_gattc_register_t *event;
1394 /* Check if GATT client registered for Default GATT client UUID */
1395 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1396 BT_INFO("UUID:%s", uuid_str);
1398 BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1399 event = g_new0(event_gattc_register_t, 1);
1400 event->client_if = clientIf;
1401 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1402 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1403 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1406 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1408 event_ble_scan_result_info *event;
1410 event = g_new0(event_ble_scan_result_info, 1);
1412 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1413 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1414 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1415 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1418 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1420 event_gattc_conn_t *event;
1421 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1422 status, client_if, conn_id);
1424 event = g_new0(event_gattc_conn_t, 1);
1425 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1426 event->client_if = client_if;
1428 if (BT_STATUS_SUCCESS != status) {
1429 event->status = OAL_STATUS_INTERNAL_ERROR;
1430 BT_ERR("gattc connection Error: %d", status);
1432 event->conn_id = conn_id;
1433 event->status = OAL_STATUS_SUCCESS;
1436 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1437 sizeof(*event), (bt_address_t *)bda);
1441 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1443 event_gattc_conn_t *event;
1444 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1445 status, client_if, conn_id);
1446 event = g_new0(event_gattc_conn_t, 1);
1447 event->status = convert_to_oal_status(status);
1448 event->client_if = client_if;
1449 event->conn_id = conn_id;
1450 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1451 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1452 sizeof(*event), (bt_address_t *)bda);
1455 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1457 char uuid_str[2*BT_UUID_STRING_MAX];
1459 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1461 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1462 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1463 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1465 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1466 event->conn_status.status = OAL_STATUS_SUCCESS;
1467 event->conn_status.conn_id = conn_id;
1468 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1470 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1473 static void cb_gattc_search_complete(int conn_id, int status)
1475 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1478 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1479 event->conn_id = conn_id;
1480 event->status = convert_to_oal_status(status);
1482 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1486 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1487 btgatt_gatt_id_t *char_id, int char_prop)
1489 char uuid_str1[2*BT_UUID_STRING_MAX];
1490 char uuid_str2[2*BT_UUID_STRING_MAX];
1492 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1493 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1494 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1495 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1497 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1498 event->conn_status.conn_id = conn_id;
1499 event->conn_status.status = convert_to_oal_status(status);
1500 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1503 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1504 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u], Prop: [%s]",
1505 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1506 event->char_prop = char_prop;
1507 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1509 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1514 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)
1516 char uuid_str1[2*BT_UUID_STRING_MAX];
1517 char uuid_str2[2*BT_UUID_STRING_MAX];
1518 char uuid_str3[2*BT_UUID_STRING_MAX];
1519 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1520 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1521 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1522 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1523 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1524 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1526 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1527 event->conn_status.conn_id = conn_id;
1528 event->conn_status.status = convert_to_oal_status(status);
1529 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1530 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1533 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1534 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, descr_id->inst_id);
1535 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1537 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1540 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)
1542 char uuid_str1[2*BT_UUID_STRING_MAX];
1543 char uuid_str2[2*BT_UUID_STRING_MAX];
1544 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1545 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1546 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1547 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1548 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1549 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1551 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1552 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1553 event->client_if = client_if;
1554 event->status = convert_to_oal_status(status);
1555 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1556 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1558 send_event(event_type, event, sizeof(*event));
1561 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1564 char uuid_str1[2*BT_UUID_STRING_MAX];
1565 char uuid_str2[2*BT_UUID_STRING_MAX];
1567 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1568 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1569 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1571 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1572 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1574 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1575 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1576 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1578 if (p_data->len > 0) {
1580 data = g_malloc(3*p_data->len+1);
1582 BT_ERR("memory allocation failed");
1586 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1587 BT_INFO("Notified Data: [%s]", data);
1589 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1590 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1591 event->is_notify = p_data->is_notify;
1592 event->data_len = p_data->len;
1593 memcpy(event->data, p_data->value, event->data_len);
1594 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1595 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1597 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1603 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1605 char uuid_str1[2*BT_UUID_STRING_MAX];
1606 char uuid_str2[2*BT_UUID_STRING_MAX];
1607 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1609 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1610 event->uuid_status.conn_status.conn_id = conn_id;
1611 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1612 event->value_type = p_data->value_type;
1613 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1614 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1616 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1617 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1618 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1619 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1620 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1621 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1622 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1624 data = g_malloc(3*p_data->value.len+1);
1626 BT_ERR("memory allocation failed");
1630 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1631 BT_INFO("Read Data: [%s]", data);
1632 event->data_len = p_data->value.len;
1633 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1637 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1640 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1642 char uuid_str1[2*BT_UUID_STRING_MAX];
1643 char uuid_str2[2*BT_UUID_STRING_MAX];
1644 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1646 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1647 event->conn_status.conn_id = conn_id;
1648 event->conn_status.status = convert_to_oal_status(status);
1649 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1650 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1652 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1653 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1654 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1655 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1656 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1658 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1661 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1663 char uuid_str1[2*BT_UUID_STRING_MAX];
1664 char uuid_str2[2*BT_UUID_STRING_MAX];
1665 char uuid_str3[2*BT_UUID_STRING_MAX];
1666 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1668 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1669 event->conn_status.conn_id = conn_id;
1670 event->conn_status.status = convert_to_oal_status(status);
1671 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1672 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1673 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1675 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1676 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1677 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1678 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1679 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1680 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1681 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1683 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1688 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1690 char uuid_str1[2*BT_UUID_STRING_MAX];
1691 char uuid_str2[2*BT_UUID_STRING_MAX];
1692 char uuid_str3[2*BT_UUID_STRING_MAX];
1693 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1695 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1696 event->uuid_status.conn_status.conn_id = conn_id;
1697 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1698 event->value_type = p_data->value_type;
1699 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1700 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1701 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1704 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1705 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1706 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1707 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1708 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1709 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1710 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1711 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1712 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1714 data = g_malloc(3*p_data->value.len+1);
1716 BT_ERR("memory allocation failed");
1720 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1721 BT_INFO("Read Data: [%s]", data);
1722 event->data_len = p_data->value.len;
1723 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1727 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1730 oal_status_t gattc_start_le_discovery(int client_id)
1733 int ret = OAL_STATUS_SUCCESS;
1735 API_TRACE("BTGATT CLIENT SCAN START");
1736 CHECK_OAL_GATT_ENABLED();
1737 CHECK_CLIENT_REGISTRATION(client_id);
1739 ret = gatt_api->client->scan(client_id, 1);
1740 if (ret != BT_STATUS_SUCCESS) {
1741 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1742 return convert_to_oal_status(ret);
1744 return OAL_STATUS_SUCCESS;
1747 oal_status_t gattc_stop_le_discovery(int client_id)
1750 int ret = OAL_STATUS_SUCCESS;
1752 API_TRACE("Scan is stopped");
1753 CHECK_OAL_GATT_ENABLED();
1754 CHECK_CLIENT_REGISTRATION(client_id);
1755 ret = gatt_api->client->scan(client_id, 0);
1756 if (ret != BT_STATUS_SUCCESS) {
1757 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1758 return convert_to_oal_status(ret);
1760 return OAL_STATUS_SUCCESS;
1763 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1767 API_TRACE("Scan is stopped");
1768 CHECK_OAL_GATT_ENABLED();
1771 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1772 if (ret != BT_STATUS_SUCCESS) {
1773 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1774 return convert_to_oal_status(ret);
1777 ret = gatt_api->client->set_scan_parameters(itv, win);
1778 if (ret != BT_STATUS_SUCCESS) {
1779 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1780 return convert_to_oal_status(ret);
1784 return OAL_STATUS_SUCCESS;
1786 /************************************ GATT Client ***********************************/
1787 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1790 char str[2*BT_UUID_STRING_MAX];
1791 int ret = OAL_STATUS_SUCCESS;
1793 CHECK_OAL_GATT_ENABLED();
1794 uuid_to_stringname(client_uuid, str);
1795 API_TRACE("uuid: [%s]", str);
1796 /* We will perform actual registration in cb_gattc_register_app callback */
1797 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1798 if (ret != BT_STATUS_SUCCESS) {
1799 BT_ERR("GATT client register failed: %s", status2string(ret));
1800 return convert_to_oal_status(ret);
1802 return OAL_STATUS_SUCCESS;
1805 oal_status_t gattc_deregister(int client_id)
1807 int ret = OAL_STATUS_SUCCESS;
1809 API_TRACE("GATT client deregister");
1810 CHECK_OAL_GATT_ENABLED();
1811 CHECK_CLIENT_REGISTRATION(client_id);
1813 ret = gatt_api->client->unregister_client(client_id);
1814 if (ret != BT_STATUS_SUCCESS) {
1815 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1816 return convert_to_oal_status(ret);
1819 return OAL_STATUS_SUCCESS;
1822 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1824 int ret = OAL_STATUS_SUCCESS;
1827 OAL_CHECK_PARAMETER(device_address, return);
1828 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1829 CHECK_OAL_GATT_ENABLED();
1830 CHECK_CLIENT_REGISTRATION(client_id);
1832 /* Handle the actual connection in cb_gattc_connection callback */
1833 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1834 if (ret != BT_STATUS_SUCCESS) {
1835 BT_ERR("GATT client connect failed: %s", status2string(ret));
1836 return convert_to_oal_status(ret);
1838 return OAL_STATUS_SUCCESS;
1841 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1844 int ret = OAL_STATUS_SUCCESS;
1847 OAL_CHECK_PARAMETER(device_address, return);
1848 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1849 CHECK_OAL_GATT_ENABLED();
1850 CHECK_CLIENT_REGISTRATION(client_id);
1851 CHECK_CLIENT_CONNECTION(conn_id);
1853 /* Handle actual disconnection in callback */
1854 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1855 if (ret != BT_STATUS_SUCCESS) {
1856 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1857 return convert_to_oal_status(ret);
1859 return OAL_STATUS_SUCCESS;
1863 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1865 int ret = OAL_STATUS_SUCCESS;
1866 char uuid_str[2*BT_UUID_STRING_MAX];
1869 uuid_to_stringname(service_uuid, uuid_str);
1870 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1872 API_TRACE("Client Service Search All");
1874 CHECK_OAL_GATT_ENABLED();
1875 CHECK_CLIENT_CONNECTION(conn_id);
1876 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1878 if (ret != BT_STATUS_SUCCESS) {
1879 BT_ERR("GATT client service search failed: %s", status2string(ret));
1880 return convert_to_oal_status(ret);
1882 return OAL_STATUS_SUCCESS;
1885 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1887 int ret = OAL_STATUS_SUCCESS;
1888 char uuid_str[2*BT_UUID_STRING_MAX];
1890 OAL_CHECK_PARAMETER(srvc_id, return);
1891 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1892 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1893 CHECK_OAL_GATT_ENABLED();
1894 CHECK_CLIENT_CONNECTION(conn_id);
1895 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1896 (btgatt_gatt_id_t *)char_id);
1897 if (ret != BT_STATUS_SUCCESS) {
1898 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1899 return convert_to_oal_status(ret);
1901 return OAL_STATUS_SUCCESS;
1904 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1905 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1907 int ret = OAL_STATUS_SUCCESS;
1908 char uuid_str1[2*BT_UUID_STRING_MAX];
1909 char uuid_str2[2*BT_UUID_STRING_MAX];
1911 OAL_CHECK_PARAMETER(srvc_id, return);
1912 OAL_CHECK_PARAMETER(char_id, return);
1913 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1914 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1915 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1916 CHECK_OAL_GATT_ENABLED();
1917 CHECK_CLIENT_CONNECTION(conn_id);
1918 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1919 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1920 if (ret != BT_STATUS_SUCCESS) {
1921 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1922 return convert_to_oal_status(ret);
1924 return OAL_STATUS_SUCCESS;
1927 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1928 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1929 int ret = OAL_STATUS_SUCCESS;
1930 char uuid_str1[2*BT_UUID_STRING_MAX];
1931 char uuid_str2[2*BT_UUID_STRING_MAX];
1934 OAL_CHECK_PARAMETER(address, return);
1935 OAL_CHECK_PARAMETER(srvc_id, return);
1936 OAL_CHECK_PARAMETER(char_id, return);
1937 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1938 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1939 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1940 CHECK_OAL_GATT_ENABLED();
1941 CHECK_CLIENT_REGISTRATION(client_id);
1943 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);
1944 if (ret != BT_STATUS_SUCCESS) {
1945 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1946 return convert_to_oal_status(ret);
1949 return OAL_STATUS_SUCCESS;
1952 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1953 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1954 int ret = OAL_STATUS_SUCCESS;
1955 char uuid_str1[2*BT_UUID_STRING_MAX];
1956 char uuid_str2[2*BT_UUID_STRING_MAX];
1959 OAL_CHECK_PARAMETER(address, return);
1960 OAL_CHECK_PARAMETER(srvc_id, return);
1961 OAL_CHECK_PARAMETER(char_id, return);
1962 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1963 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1964 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1965 CHECK_OAL_GATT_ENABLED();
1966 CHECK_CLIENT_REGISTRATION(client_id);
1968 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);
1969 if (ret != BT_STATUS_SUCCESS) {
1970 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
1971 return convert_to_oal_status(ret);
1974 return OAL_STATUS_SUCCESS;
1978 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1979 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
1981 int ret = OAL_STATUS_SUCCESS;
1982 char uuid_str1[2*BT_UUID_STRING_MAX];
1983 char uuid_str2[2*BT_UUID_STRING_MAX];
1985 OAL_CHECK_PARAMETER(srvc_id, return);
1986 OAL_CHECK_PARAMETER(char_id, return);
1987 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1988 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1989 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1990 CHECK_OAL_GATT_ENABLED();
1991 CHECK_CLIENT_CONNECTION(conn_id);
1993 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1994 (btgatt_gatt_id_t *)char_id, auth_req);
1995 if (ret != BT_STATUS_SUCCESS) {
1996 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
1997 return convert_to_oal_status(ret);
2000 return OAL_STATUS_SUCCESS;
2003 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2004 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2006 int ret = OAL_STATUS_SUCCESS;
2007 char uuid_str1[2*BT_UUID_STRING_MAX];
2008 char uuid_str2[2*BT_UUID_STRING_MAX];
2009 char uuid_str3[2*BT_UUID_STRING_MAX];
2011 OAL_CHECK_PARAMETER(srvc_id, return);
2012 OAL_CHECK_PARAMETER(char_id, return);
2013 OAL_CHECK_PARAMETER(desc_id, return);
2014 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2015 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2016 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2017 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2018 uuid_str1, uuid_str2, uuid_str3);
2019 CHECK_OAL_GATT_ENABLED();
2020 CHECK_CLIENT_CONNECTION(conn_id);
2022 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2023 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2024 if (ret != BT_STATUS_SUCCESS) {
2025 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2026 return convert_to_oal_status(ret);
2029 return OAL_STATUS_SUCCESS;
2032 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2033 oal_gatt_id_t *char_id, int *fd, int *mtu)
2035 int ret = OAL_STATUS_SUCCESS;
2036 char uuid_str1[2*BT_UUID_STRING_MAX];
2037 char uuid_str2[2*BT_UUID_STRING_MAX];
2038 OAL_CHECK_PARAMETER(srvc_id, return);
2039 OAL_CHECK_PARAMETER(char_id, return);
2040 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2041 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2042 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2043 CHECK_OAL_GATT_ENABLED();
2044 CHECK_CLIENT_CONNECTION(conn_id);
2046 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2047 (btgatt_gatt_id_t *)char_id, fd, mtu);
2048 if (ret != BT_STATUS_SUCCESS) {
2049 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2050 return convert_to_oal_status(ret);
2053 return OAL_STATUS_SUCCESS;
2056 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2057 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2059 int ret = OAL_STATUS_SUCCESS;
2060 char uuid_str1[2*BT_UUID_STRING_MAX];
2061 char uuid_str2[2*BT_UUID_STRING_MAX];
2062 OAL_CHECK_PARAMETER(srvc_id, return);
2063 OAL_CHECK_PARAMETER(char_id, return);
2064 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2065 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2066 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2067 CHECK_OAL_GATT_ENABLED();
2068 CHECK_CLIENT_CONNECTION(conn_id);
2070 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2071 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2072 if (ret != BT_STATUS_SUCCESS) {
2073 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2074 return convert_to_oal_status(ret);
2077 return OAL_STATUS_SUCCESS;
2080 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2081 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2082 int len, oal_gatt_auth_req_t auth_req, char* data)
2084 int ret = OAL_STATUS_SUCCESS;
2085 char uuid_str1[2*BT_UUID_STRING_MAX];
2086 char uuid_str2[2*BT_UUID_STRING_MAX];
2087 OAL_CHECK_PARAMETER(srvc_id, return);
2088 OAL_CHECK_PARAMETER(char_id, return);
2089 OAL_CHECK_PARAMETER(data, return);
2090 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2091 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2092 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2093 CHECK_OAL_GATT_ENABLED();
2094 CHECK_CLIENT_CONNECTION(conn_id);
2096 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2097 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2098 if (ret != BT_STATUS_SUCCESS) {
2099 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2100 return convert_to_oal_status(ret);
2103 return OAL_STATUS_SUCCESS;
2106 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2107 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2108 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2110 int ret = OAL_STATUS_SUCCESS;
2111 char uuid_str1[2*BT_UUID_STRING_MAX];
2112 char uuid_str2[2*BT_UUID_STRING_MAX];
2113 char uuid_str3[2*BT_UUID_STRING_MAX];
2114 OAL_CHECK_PARAMETER(srvc_id, return);
2115 OAL_CHECK_PARAMETER(char_id, return);
2116 OAL_CHECK_PARAMETER(desc_id, return);
2117 OAL_CHECK_PARAMETER(data, return);
2118 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2119 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2120 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2121 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2122 uuid_str1, uuid_str2, uuid_str3);
2123 CHECK_OAL_GATT_ENABLED();
2124 CHECK_CLIENT_CONNECTION(conn_id);
2126 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2127 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_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_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2141 OAL_CHECK_PARAMETER(address, return);
2142 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2143 CHECK_OAL_GATT_ENABLED();
2145 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2146 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2147 if (ret != BT_STATUS_SUCCESS) {
2148 BT_ERR("error: %s", status2string(ret));
2149 return convert_to_oal_status(ret);
2151 return OAL_STATUS_SUCCESS;
2154 oal_status_t gattc_unregister_scan_filter(int slot_id)
2160 CHECK_OAL_GATT_ENABLED();
2162 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2164 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2165 if (ret != BT_STATUS_SUCCESS) {
2166 BT_ERR("error: %s", status2string(ret));
2167 return convert_to_oal_status(ret);
2169 return OAL_STATUS_SUCCESS;
2172 oal_status_t gattc_enable_scan_filter(int client_if)
2177 CHECK_OAL_GATT_ENABLED();
2179 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2181 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2182 if (ret != BT_STATUS_SUCCESS) {
2183 BT_ERR("error: %s", status2string(ret));
2184 return convert_to_oal_status(ret);
2186 return OAL_STATUS_SUCCESS;
2189 oal_status_t gattc_disable_scan_filter(int client_if)
2194 CHECK_OAL_GATT_ENABLED();
2196 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2198 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2199 if (ret != BT_STATUS_SUCCESS) {
2200 BT_ERR("error: %s", status2string(ret));
2201 return convert_to_oal_status(ret);
2203 return OAL_STATUS_SUCCESS;
2206 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2209 int client_info = 0;
2212 int company_id_mask = 0;
2213 int address_type = 0;
2214 int feature_selection = 0;
2216 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2217 .filt_logic_type = 1,
2218 .rssi_high_thres = -127,
2219 .rssi_low_thres = -127,
2223 .found_timeout_cnt = 0
2226 OAL_CHECK_PARAMETER(filter_data, return);
2228 CHECK_OAL_GATT_ENABLED();
2230 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2232 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2233 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2234 ret = gatt_api->client->scan_filter_add_remove(client_info,
2236 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2237 filter_data->slot_id,
2242 (bt_bdaddr_t*)filter_data->device_address,
2249 if (ret != BT_STATUS_SUCCESS){
2250 BT_ERR("error: %s", status2string(ret));
2251 BT_INFO("unregistering already set filter features.");
2252 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2253 return convert_to_oal_status(ret);
2256 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2258 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2259 ret = gatt_api->client->scan_filter_add_remove(client_info,
2261 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2262 filter_data->slot_id,
2270 filter_data->device_name, // device_name as p_data in HAL
2274 if (ret != BT_STATUS_SUCCESS){
2275 BT_ERR("error: %s", status2string(ret));
2276 BT_INFO("unregistering already set filter features.");
2277 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2278 return convert_to_oal_status(ret);
2281 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2283 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2284 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2285 char uuid_str1[2*BT_UUID_STRING_MAX];
2286 char uuid_str2[2*BT_UUID_STRING_MAX];
2288 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2289 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2291 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2292 ret = gatt_api->client->scan_filter_add_remove(client_info,
2294 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2295 filter_data->slot_id,
2298 (bt_uuid_t*)filter_data->service_uuid,
2299 (bt_uuid_t*)filter_data->service_uuid_mask,
2302 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2304 filter_data->service_uuid_mask_len,
2307 if (ret != BT_STATUS_SUCCESS){
2308 BT_ERR("error: %s", status2string(ret));
2309 BT_INFO("unregistering already set filter features.");
2310 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2311 return convert_to_oal_status(ret);
2314 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2316 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2317 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2318 char uuid_str1[2*BT_UUID_STRING_MAX];
2319 char uuid_str2[2*BT_UUID_STRING_MAX];
2320 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2321 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2322 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2323 ret = gatt_api->client->scan_filter_add_remove(client_info,
2325 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2326 filter_data->slot_id,
2329 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2330 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2333 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2335 filter_data->service_solicitation_uuid_mask_len,
2338 if (ret != BT_STATUS_SUCCESS){
2339 BT_ERR("error: %s", status2string(ret));
2340 BT_INFO("unregistering already set filter features.");
2341 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2342 return convert_to_oal_status(ret);
2345 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2347 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2348 ret = gatt_api->client->scan_filter_add_remove(client_info,
2350 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2351 filter_data->slot_id,
2358 filter_data->service_data_len, //service_data_len as data_len in HAL
2359 (char*)filter_data->service_data,
2360 filter_data->service_data_mask_len,
2361 (char*)filter_data->service_data_mask
2363 if (ret != BT_STATUS_SUCCESS){
2364 BT_ERR("error: %s", status2string(ret));
2365 BT_INFO("unregistering already set filter features.");
2366 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2367 return convert_to_oal_status(ret);
2370 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2372 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2373 ret = gatt_api->client->scan_filter_add_remove(client_info,
2375 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2376 filter_data->slot_id,
2377 filter_data->manufacturer_id,
2383 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2384 (char*)filter_data->manufacturer_data,
2385 filter_data->manufacturer_data_mask_len,
2386 (char*)filter_data->manufacturer_data_mask
2388 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2389 if (ret != BT_STATUS_SUCCESS){
2390 BT_ERR("error: %s", status2string(ret));
2391 BT_INFO("unregistering already set filter features.");
2392 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2393 return convert_to_oal_status(ret);
2396 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2399 BT_DBG("Filter selection 0x%.2x", feature_selection);
2401 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2402 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2403 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2404 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2405 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2406 if (ret != BT_STATUS_SUCCESS){
2407 BT_ERR("error: %s", status2string(ret));
2408 return convert_to_oal_status(ret);
2410 return OAL_STATUS_SUCCESS;