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.
24 #include <bluetooth.h>
26 #include "oal-event.h"
27 #include "oal-internal.h"
28 #include "oal-common.h"
29 #include "oal-manager.h"
30 #include "oal-utils.h"
31 #include "oal-device-mgr.h"
33 static const bt_interface_t * blued_api;
35 void device_mgr_init(const bt_interface_t * stack_if)
40 void device_mgr_cleanup(void)
46 oal_status_t device_query_attributes(bt_address_t *addr)
51 CHECK_OAL_INITIALIZED();
53 OAL_CHECK_PARAMETER(addr, return);
55 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
57 res = blued_api->get_remote_device_properties((bt_bdaddr_t *)addr);
58 if (res != BT_STATUS_SUCCESS) {
59 BT_ERR("get_remote_device_properties error: [%s]", status2string(res));
60 return convert_to_oal_status(res);
63 return OAL_STATUS_SUCCESS;
66 oal_status_t device_query_services(bt_address_t * addr)
71 CHECK_OAL_INITIALIZED();
73 OAL_CHECK_PARAMETER(addr, return);
75 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
77 res = blued_api->get_remote_services((bt_bdaddr_t *)addr);
78 if (res != BT_STATUS_SUCCESS) {
79 BT_ERR("get_remote_services error: [%s]", status2string(res));
80 return convert_to_oal_status(res);
83 return OAL_STATUS_SUCCESS;
86 oal_status_t device_stop_query_sevices(bt_address_t * addr)
88 CHECK_OAL_INITIALIZED();
90 OAL_CHECK_PARAMETER(addr, return);
92 API_TRACE("Stop SDP search");
93 /* Currently no HAL Interface for Stopping Service Search */
94 return BT_STATUS_UNSUPPORTED;
97 oal_status_t device_set_alias(bt_address_t * addr, char * alias)
103 CHECK_OAL_INITIALIZED();
104 OAL_CHECK_PARAMETER(addr, return);
105 OAL_CHECK_PARAMETER(alias, return);
107 API_TRACE("%s ->Alias: %s", bdt_bd2str(addr, &bdstr) + 12, alias);
109 prop.type = BT_PROPERTY_REMOTE_FRIENDLY_NAME;
110 prop.len = strlen(alias);
112 res = blued_api->set_remote_device_property((bt_bdaddr_t*)addr, &prop);
113 if (res != BT_STATUS_SUCCESS) {
114 BT_ERR("set_remote_device_property error: [%s]", status2string(res));
115 BT_ERR("Alias: %s", alias);
116 return convert_to_oal_status(res);
119 return OAL_STATUS_SUCCESS;
122 oal_status_t device_create_bond(bt_address_t *addr, oal_conn_type_e transport)
127 CHECK_OAL_INITIALIZED();
129 OAL_CHECK_PARAMETER(addr, return);
131 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
133 res = blued_api->create_bond((bt_bdaddr_t *)addr, transport);
134 if (res != BT_STATUS_SUCCESS) {
135 BT_ERR("create_bond error: [%s]", status2string(res));
136 return convert_to_oal_status(res);
139 return OAL_STATUS_SUCCESS;
142 oal_status_t device_destroy_bond(bt_address_t * addr)
147 CHECK_OAL_INITIALIZED();
149 OAL_CHECK_PARAMETER(addr, return);
151 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
153 res = blued_api->remove_bond((bt_bdaddr_t *)addr);
154 if (res != BT_STATUS_SUCCESS) {
155 BT_ERR("remove_bond error: [%s]", status2string(res));
156 return convert_to_oal_status(res);
159 return OAL_STATUS_SUCCESS;
162 oal_status_t device_stop_bond(bt_address_t * addr)
167 CHECK_OAL_INITIALIZED();
169 OAL_CHECK_PARAMETER(addr, return);
171 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
173 res = blued_api->cancel_bond((bt_bdaddr_t *)addr);
174 if (res != BT_STATUS_SUCCESS) {
175 BT_ERR("cancel_bond error: [%s]", status2string(res));
176 return convert_to_oal_status(res);
179 return OAL_STATUS_SUCCESS;
182 oal_status_t device_get_ida(bt_address_t *device_address, bt_address_t *id_address)
186 CHECK_OAL_INITIALIZED();
188 OAL_CHECK_PARAMETER(device_address, return);
192 res = blued_api->get_device_ida((bt_bdaddr_t*) device_address, (bt_bdaddr_t*) id_address);
194 if (res != BT_STATUS_SUCCESS)
195 BT_ERR("get_device_IDA failed: [%s]",status2string(res));
197 res = convert_to_oal_status(res);
201 oal_status_t device_accept_pin_request(bt_address_t * addr, const char * pin)
206 CHECK_OAL_INITIALIZED();
208 OAL_CHECK_PARAMETER(addr, return);
209 OAL_CHECK_PARAMETER(pin, return);
211 API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr) + 12, pin);
213 res = blued_api->pin_reply((bt_bdaddr_t *)addr, TRUE, strlen(pin), (bt_pin_code_t *)pin);
214 if (res != BT_STATUS_SUCCESS) {
215 BT_ERR("pin_reply error: [%s]", status2string(res));
216 BT_ERR("PIN: %s", pin);
217 return convert_to_oal_status(res);
220 return OAL_STATUS_SUCCESS;
223 oal_status_t device_reject_pin_request(bt_address_t * addr)
228 CHECK_OAL_INITIALIZED();
230 OAL_CHECK_PARAMETER(addr, return);
232 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
234 res = blued_api->pin_reply((bt_bdaddr_t *)addr, FALSE, 0, NULL);
235 if (res != BT_STATUS_SUCCESS) {
236 BT_ERR("pin_reply error: [%s]", status2string(res));
237 return convert_to_oal_status(res);
240 return OAL_STATUS_SUCCESS;
243 oal_status_t device_accept_passkey_entry(bt_address_t * addr, uint32_t passkey)
248 CHECK_OAL_INITIALIZED();
250 OAL_CHECK_PARAMETER(addr, return);
252 API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr) + 12, passkey);
254 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, TRUE, passkey);
255 if (res != BT_STATUS_SUCCESS) {
256 BT_ERR("ssp_reply error: [%s]", status2string(res));
257 BT_ERR("Passkey: %d", passkey);
258 return convert_to_oal_status(res);
262 return OAL_STATUS_SUCCESS;
265 oal_status_t device_reject_passkey_entry(bt_address_t * addr)
270 CHECK_OAL_INITIALIZED();
272 OAL_CHECK_PARAMETER(addr, return);
274 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
276 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, FALSE, 0);
277 if (res != BT_STATUS_SUCCESS) {
278 BT_ERR("ssp_reply error: [%s]", status2string(res));
279 return convert_to_oal_status(res);
282 return OAL_STATUS_SUCCESS;
285 oal_status_t device_reply_passkey_confirmation(bt_address_t * addr, int accept)
290 CHECK_OAL_INITIALIZED();
292 OAL_CHECK_PARAMETER(addr, return);
294 API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr) + 12, accept);
296 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_CONFIRMATION, accept, 0);
297 if (res != BT_STATUS_SUCCESS) {
298 BT_ERR("ssp_reply error: [%s]", status2string(res));
299 BT_ERR("%d", accept);
300 return convert_to_oal_status(res);
303 return OAL_STATUS_SUCCESS;
307 oal_status_t device_reply_ssp_consent(bt_address_t * addr, int accept)
312 CHECK_OAL_INITIALIZED();
314 OAL_CHECK_PARAMETER(addr, return);
316 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, accept);
318 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_CONSENT, accept, 0);
319 if (res != BT_STATUS_SUCCESS) {
320 BT_ERR("ssp_reply error: [%s]", status2string(res));
321 BT_ERR("%d", accept);
322 return convert_to_oal_status(res);
325 return OAL_STATUS_SUCCESS;
328 oal_status_t device_reply_auth_request(bt_address_t * addr, oal_service_t service_type, int accept, int always)
333 CHECK_OAL_INITIALIZED();
335 OAL_CHECK_PARAMETER(addr, return);
337 API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr) + 12, accept, always, service_type);
339 res = blued_api->authorize_response((bt_bdaddr_t *)addr, service_type, accept, always);
340 if (res != BT_STATUS_SUCCESS) {
341 BT_ERR("authorize_response error: [%s]", status2string(res));
342 BT_ERR("Accept: [%d], always: [%d], service_type: [%d]", accept, always, service_type);
343 return convert_to_oal_status(res);
346 return OAL_STATUS_SUCCESS;
349 oal_status_t device_set_authorized(bt_address_t * addr, int authorize)
354 CHECK_OAL_INITIALIZED();
356 OAL_CHECK_PARAMETER(addr, return);
358 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, authorize);
360 res = blued_api->set_authorization((bt_bdaddr_t *)addr, authorize);
361 if (res != BT_STATUS_SUCCESS) {
362 BT_ERR("set_authorization error: [%s]", status2string(res));
363 BT_ERR("%d", authorize);
364 return convert_to_oal_status(res);
367 return OAL_STATUS_SUCCESS;
370 gboolean device_get_acl_conn_state(bt_address_t * addr)
375 CHECK_OAL_INITIALIZED();
376 OAL_CHECK_PARAMETER(addr, return);
378 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
380 res = blued_api->get_connection_state((bt_bdaddr_t *)addr);
381 BT_ERR("get_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
386 gboolean device_get_svc_conn_state(bt_address_t * addr, oal_service_t svc_id)
391 CHECK_OAL_INITIALIZED();
392 OAL_CHECK_PARAMETER(addr, return);
394 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr) + 12, svc_id);
397 res = blued_api->get_service_connection_state((bt_bdaddr_t *)addr, svc_id);
399 BT_ERR("Not supported");
402 BT_ERR("get_service_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
407 oal_status_t device_register_osp_server(oal_osp_server_type_e type, char *uuid, char *path, int fd)
410 uint32_t server_type;
412 CHECK_OAL_INITIALIZED();
414 API_TRACE("type: %d", type);
418 case OAL_OSP_SERVER_OBEX:
419 server_type = BT_OSP_SERVER_OBEX;
421 case OAL_OSP_SERVER_RFCOMM:
422 server_type = BT_OSP_SERVER_RFCOMM;
425 BT_ERR("unknown type: %d", type);
426 return OAL_STATUS_INVALID_PARAM;
429 res = blued_api->register_agent_osp_server(server_type, uuid, path, fd);
430 if (res != BT_STATUS_SUCCESS) {
431 BT_ERR("register_agent_osp_server error: [%s]", status2string(res));
432 return convert_to_oal_status(res);
435 return OAL_STATUS_SUCCESS;
437 BT_ERR("Not supported");
438 res = OAL_STATUS_NOT_SUPPORT;
443 oal_status_t device_unregister_osp_server(oal_osp_server_type_e type, char *uuid)
446 uint32_t server_type;
448 CHECK_OAL_INITIALIZED();
450 API_TRACE("type: %d", type);
454 case OAL_OSP_SERVER_OBEX:
455 server_type = BT_OSP_SERVER_OBEX;
457 case OAL_OSP_SERVER_RFCOMM:
458 server_type = BT_OSP_SERVER_RFCOMM;
461 BT_ERR("unknown type: %d", type);
462 return OAL_STATUS_INVALID_PARAM;
465 res = blued_api->unregister_agent_osp_server(server_type, uuid);
466 if (res != BT_STATUS_SUCCESS) {
467 BT_ERR("unregister_agent_osp_server error: [%s]", status2string(res));
468 return convert_to_oal_status(res);
471 return OAL_STATUS_SUCCESS;
473 BT_ERR("Not supported");
474 res = OAL_STATUS_NOT_SUPPORT;
479 oal_status_t device_set_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, gboolean trust)
484 CHECK_OAL_INITIALIZED();
486 OAL_CHECK_PARAMETER(addr, return);
488 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
491 res = blued_api->set_trusted_profile((bt_bdaddr_t *)addr, profile, (trust ? 1 : 0));
492 if (res != BT_STATUS_SUCCESS) {
493 BT_ERR("set_trusted_profile error: [%s]", status2string(res));
494 return convert_to_oal_status(res);
497 return OAL_STATUS_SUCCESS;
499 BT_ERR("Not supported");
500 res = OAL_STATUS_NOT_SUPPORT;
505 oal_status_t device_get_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, unsigned int *trusted)
510 CHECK_OAL_INITIALIZED();
512 OAL_CHECK_PARAMETER(addr, return);
514 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
517 res = blued_api->get_trusted_profile((bt_bdaddr_t *)addr, profile, trusted);
518 if (res != BT_STATUS_SUCCESS) {
519 BT_ERR("get_trusted_profile error: [%s]", status2string(res));
520 return convert_to_oal_status(res);
523 return OAL_STATUS_SUCCESS;
525 BT_ERR("Not supported");
526 res = OAL_STATUS_NOT_SUPPORT;
531 oal_status_t device_enable_rssi_monitoring(bt_address_t *addr, unsigned int link_type,
532 int low_threshold, int in_range_threshold, int high_threshold)
537 CHECK_OAL_INITIALIZED();
539 OAL_CHECK_PARAMETER(addr, return);
541 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
544 res = blued_api->enable_rssi_monitoring((bt_bdaddr_t *)addr, link_type,
545 low_threshold, in_range_threshold, high_threshold);
546 if (res != BT_STATUS_SUCCESS) {
547 BT_ERR("enable_rssi_monitoring error: [%s]", status2string(res));
548 return convert_to_oal_status(res);
551 return OAL_STATUS_SUCCESS;
553 BT_ERR("Not supported");
554 res = OAL_STATUS_NOT_SUPPORT;
559 oal_status_t device_get_connected_link_rssi_strength(bt_address_t *addr, unsigned int link_type)
564 CHECK_OAL_INITIALIZED();
566 OAL_CHECK_PARAMETER(addr, return);
568 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
571 res = blued_api->get_connected_link_rssi_strength((bt_bdaddr_t *)addr, link_type);
572 if (res != BT_STATUS_SUCCESS) {
573 BT_ERR("get_connected_link_rssi_strength error: [%s]", status2string(res));
574 return convert_to_oal_status(res);
577 return OAL_STATUS_SUCCESS;
579 BT_ERR("Not supported");
580 res = OAL_STATUS_NOT_SUPPORT;
585 oal_status_t device_enable_gap_auth_notifications(oal_gap_auth_type_e type, gboolean enable)
589 CHECK_OAL_INITIALIZED();
591 API_TRACE("type: [%d], enable: %d", type, enable);
594 res = blued_api->enable_gap_auth_notifications(type, (enable ? 1 : 0));
595 if (res != BT_STATUS_SUCCESS) {
596 BT_ERR("enable_gap_auth_notifications error: [%s]", status2string(res));
597 return convert_to_oal_status(res);
600 return OAL_STATUS_SUCCESS;
602 BT_ERR("Not supported");
603 res = OAL_STATUS_NOT_SUPPORT;
608 oal_status_t device_disconnect(bt_address_t * addr)
613 CHECK_OAL_INITIALIZED();
615 OAL_CHECK_PARAMETER(addr, return);
617 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr) + 12);
619 res = blued_api->device_disconnect((bt_bdaddr_t *)addr);
620 if (res != BT_STATUS_SUCCESS) {
621 BT_ERR("device_disconnect error: [%s]", status2string(res));
622 return convert_to_oal_status(res);
625 return OAL_STATUS_SUCCESS;
628 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
629 int num_properties, bt_property_t *properties)
632 gpointer event_data = NULL;
633 remote_device_t *dev_info;
634 ble_adv_data_t adv_info;
638 BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr) + 12,
639 status, num_properties);
641 dev_info = g_new0(remote_device_t, 1);
642 memcpy(dev_info->address.addr, bd_addr->address, 6);
643 parse_device_properties(num_properties, properties, dev_info, &adv_info);
645 if (num_properties == 0) {
646 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
647 /* It is possible that app called get bonded device info for a device
648 which is not yet bonded or udner bonding, in such case, stack will return no properties.
649 It is also possible that after bonding is done, BT MW attempted to fetch
650 bonded device info, but due to internal stack error, 0 properties with status FAIL
651 are received from stack. In such cases, simply send the event to BT MW
652 and let it handle this event */
653 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
654 memcpy(&dev_props_event->device_info,
655 dev_info, sizeof(remote_device_t));
656 event_data = dev_props_event;
657 event = OAL_EVENT_DEVICE_PROPERTIES;
658 size = sizeof(event_dev_properties_t);
660 } else if (num_properties == 1) {
661 /* For one particular property a dedicated event to be sent */
662 switch (properties[0].type) {
663 case BT_PROPERTY_BDNAME:
664 event = OAL_EVENT_DEVICE_NAME;
665 event_data = dev_info;
666 send_event_trace(event, event_data, sizeof(remote_device_t),
667 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
669 case BT_PROPERTY_UUIDS: {
670 event_dev_services_t *services_info;
671 bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
672 BT_DBG("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
674 services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
675 services_info->address = dev_info->address;
676 memcpy(services_info->service_list, uuids, properties[0].len);
677 services_info->num = properties[0].len/sizeof(bt_uuid_t);
678 BT_DBG("Number of UUID [%d]", services_info->num);
679 event = OAL_EVENT_DEVICE_SERVICES;
680 event_data = services_info;
681 size = sizeof(event_dev_services_t) + properties[0].len;
686 BT_ERR("Single Property [%d] not handled", properties[0].type);
691 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
692 if (dev_info->type != DEV_TYPE_BREDR) {
695 BT_DBG("BLE Device");
696 /* BLE Single or DUAL mode found, so it should have Adv data */
697 dev_props_event->adv_len = adv_info.len;
698 if (dev_props_event->adv_len > 0)
699 memcpy(dev_props_event->adv_data,
700 adv_info.adv_data, adv_info.len);
702 for (i = 0; i < dev_props_event->adv_len; i++)
703 BT_DBG("Adv Data[%d] = [0x%x]",
704 i, dev_props_event->adv_data[i]);
705 memcpy(&dev_props_event->device_info,
706 dev_info, sizeof(remote_device_t));
708 BT_DBG("BREDR type Device");
709 memcpy(&dev_props_event->device_info,
710 dev_info, sizeof(remote_device_t));
713 event_data = dev_props_event;
714 event = OAL_EVENT_DEVICE_PROPERTIES;
715 size = sizeof(event_dev_properties_t);
719 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
722 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
723 bt_bond_state_t state)
725 bt_address_t * address = g_new0(bt_address_t, 1);
729 BT_DBG("status: %d, state: %d", status, state);
731 memcpy(address->addr, bd_addr->address, 6);
734 case BT_BOND_STATE_BONDED:
735 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
737 case BT_BOND_STATE_NONE:
738 /* Reaches both when bonding removed or bonding cancelled */
739 if (BT_STATUS_SUCCESS != status) {
740 event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
741 bond_fail_info->status = convert_to_oal_status(status);
742 bond_fail_info->address = *address;
743 size = sizeof(event_dev_bond_failed_t);
744 send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
748 event = OAL_EVENT_DEVICE_BONDING_REMOVED;
750 case BT_BOND_STATE_BONDING:
754 BT_ERR("Unexpected Bond state %d", state);
758 send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
761 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
762 bt_acl_state_t state)
764 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
768 memcpy(conn_status->address.addr, bd_addr->address, 6);
771 conn_status->status = status;
773 if (BT_STATUS_SUCCESS != status) {
774 /* At present only timeout will cause non-success status, later we can add more */
775 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
776 BT_ERR("ACL State Error:%d, state: %d", status, state);
778 conn_status->status = OAL_STATUS_SUCCESS;
780 memcpy(conn_status->address.addr, bd_addr->address, 6);
783 BT_INFO("[ACL] Status: %d, State: %d", conn_status->status, state);
786 case BT_ACL_STATE_CONNECTED:
787 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
788 conn_status->status = OAL_STATUS_SUCCESS;
790 case BT_ACL_STATE_DISCONNECTED:
791 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
794 BT_ERR("Unexpected ACL state %d", state);
799 size = sizeof(event_dev_conn_status_t);
800 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
804 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
805 bt_le_conn_state_t state)
807 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
811 memcpy(conn_status->address.addr, bd_addr->address, 6);
812 conn_status->status = status;
813 BT_INFO("[LE ACL] Status: %d, State: %d", conn_status->status, state);
816 case BT_LE_CONN_STATE_CONNECTED:
817 event = OAL_EVENT_DEVICE_LE_CONNECTED;
819 case BT_LE_CONN_STATE_DISCONNECTED:
820 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
823 BT_ERR("Unexpected ACL state %d", state);
828 size = sizeof(event_dev_conn_status_t);
829 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
833 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
835 remote_device_t * dev_info = g_new0(remote_device_t, 1);
839 memcpy(dev_info->address.addr, bd_addr->address, 6);
840 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
841 dev_info->cod = device_class;
842 size = sizeof(remote_device_t);
844 send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
847 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
848 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
851 gpointer event_data = NULL;
855 switch (pairing_variant) {
856 case BT_SSP_VARIANT_PASSKEY_ENTRY:
858 remote_device_t * dev_info = g_new0(remote_device_t, 1);
859 memcpy(dev_info->address.addr, bd_addr->address, 6);
860 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
861 dev_info->cod = device_class;
862 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
863 event_data = dev_info;
864 size = sizeof(remote_device_t);
867 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
869 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
871 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
872 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
873 passkey_data->device_info.cod = device_class;
874 passkey_data->pass_key = pass_key;
875 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
876 event_data = passkey_data;
877 size = sizeof(event_dev_passkey_t);
880 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
882 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
884 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
885 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
886 passkey_data->device_info.cod = device_class;
887 passkey_data->pass_key = pass_key;
888 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
889 event_data = passkey_data;
890 size = sizeof(event_dev_passkey_t);
893 case BT_SSP_VARIANT_CONSENT:
895 remote_device_t * dev_info = g_new0(remote_device_t, 1);
897 memcpy(dev_info->address.addr, bd_addr->address, 6);
898 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
899 dev_info->cod = device_class;
900 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
901 event_data = dev_info;
902 size = sizeof(remote_device_t);
907 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
911 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
914 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
916 event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
918 BT_INFO("service_d: %d", service_d);
919 memcpy(auth_req->address.addr, bd_addr->address, 6);
920 auth_req->service_id = service_d;
922 send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
925 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
928 event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
930 if (trusted == BT_DEVICE_TRUSTED) {
931 BT_INFO("Device is Trusted");
932 event = OAL_EVENT_DEVICE_TRUSTED;
934 BT_INFO("Device is Un Trusted");
935 event = OAL_EVENT_DEVICE_UNTRUSTED;
937 memcpy(trust_val->address.addr, bd_addr->address, 6);
938 trust_val->status = OAL_STATUS_SUCCESS;
939 send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
943 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid, uint8_t *name, uint8_t *path, uint32_t fd)
945 event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
947 memcpy(auth_req->address.addr, bd_addr->address, 6);
948 memcpy(auth_req->uuid.uuid, uuid->uu, 16);
949 memcpy(auth_req->name, name, sizeof(auth_req->name) - 1);
950 memcpy(auth_req->path, path, sizeof(auth_req->path) - 1);
953 send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
956 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
958 event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
962 memcpy(ev->address.addr, bd_addr->address, 6);
963 ev->trust_val = trust_val;
964 send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
965 ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
969 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
971 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
972 oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
976 memcpy(ev->address.addr, bd_addr->address, 6);
977 ev->link_type = link_type;
979 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
981 send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
986 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
988 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
992 memcpy(ev->address.addr, bd_addr->address, 6);
993 ev->link_type = link_type;
994 ev->alert_type = alert_type;
997 send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
998 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
1002 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
1004 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
1008 memcpy(ev->address.addr, bd_addr->address, 6);
1009 ev->link_type = link_type;
1012 send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
1013 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
1017 void cb_dbfw_plus_info_received(unsigned char *data, uint32_t length, uint8_t event_code)
1019 event_dev_dbfw_plus_info_t *dbfw_info;
1020 int len = (length > 512)?512:length;
1022 ret_if(data == NULL || length == 0);
1024 dbfw_info = g_new0(event_dev_dbfw_plus_info_t, 1);
1025 dbfw_info->event_code = event_code;
1026 memcpy(dbfw_info->data, data, len);
1027 dbfw_info->length = len;
1029 send_event(OAL_EVENT_DEVICE_DBFW_PLUS_INFO,
1030 dbfw_info, sizeof(event_dev_dbfw_plus_info_t));