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));
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));
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), 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));
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));
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));
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), 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));
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), 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));
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), 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), 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), 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), 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));
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), 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));
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));
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));
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));
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));
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),
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_INFO("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_INFO("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_INFO("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_INFO("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_INFO("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);
765 //bt_address_t * address = g_new0(bt_address_t, 1);
769 BT_DBG("ACL State:%d, state: %d", status, state);
771 memcpy(conn_status->address.addr, bd_addr->address, 6);
774 conn_status->status = convert_to_oal_status(status);
776 if (BT_STATUS_SUCCESS != status) {
777 /* At present only timeout will cause non-success status, later we can add more */
778 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
779 BT_ERR("ACL State Error:%d, state: %d", status, state);
781 conn_status->status = OAL_STATUS_SUCCESS;
783 memcpy(conn_status->address.addr, bd_addr->address, 6);
786 BT_INFO("ACL STATE :%d, conn_status->status :%d, BT_ACL_STATE: %d", status, conn_status->status, state);
789 case BT_ACL_STATE_CONNECTED:
790 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
791 conn_status->status = OAL_STATUS_SUCCESS;
793 case BT_ACL_STATE_DISCONNECTED:
794 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
797 BT_ERR("Unexpected ACL state %d", state);
802 size = sizeof(event_dev_conn_status_t);
803 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
807 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
808 bt_le_conn_state_t state)
810 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
811 //bt_address_t * address = g_new0(bt_address_t, 1);
815 BT_DBG("LE conn status:%d, state: %d", status, state);
816 memcpy(conn_status->address.addr, bd_addr->address, 6);
817 conn_status->status = convert_to_oal_status(status);
820 case BT_LE_CONN_STATE_CONNECTED:
821 event = OAL_EVENT_DEVICE_LE_CONNECTED;
823 case BT_LE_CONN_STATE_DISCONNECTED:
824 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
827 BT_ERR("Unexpected ACL state %d", state);
832 size = sizeof(event_dev_conn_status_t);
833 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
837 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
839 remote_device_t * dev_info = g_new0(remote_device_t, 1);
843 memcpy(dev_info->address.addr, bd_addr->address, 6);
844 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
845 dev_info->cod = device_class;
846 size = sizeof(remote_device_t);
848 send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
851 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
852 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
855 gpointer event_data = NULL;
859 switch (pairing_variant) {
860 case BT_SSP_VARIANT_PASSKEY_ENTRY:
862 remote_device_t * dev_info = g_new0(remote_device_t, 1);
863 memcpy(dev_info->address.addr, bd_addr->address, 6);
864 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
865 dev_info->cod = device_class;
866 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
867 event_data = dev_info;
868 size = sizeof(remote_device_t);
871 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
873 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
875 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
876 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
877 passkey_data->device_info.cod = device_class;
878 passkey_data->pass_key = pass_key;
879 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
880 event_data = passkey_data;
881 size = sizeof(event_dev_passkey_t);
884 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
886 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
888 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
889 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
890 passkey_data->device_info.cod = device_class;
891 passkey_data->pass_key = pass_key;
892 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
893 event_data = passkey_data;
894 size = sizeof(event_dev_passkey_t);
897 case BT_SSP_VARIANT_CONSENT:
899 remote_device_t * dev_info = g_new0(remote_device_t, 1);
901 memcpy(dev_info->address.addr, bd_addr->address, 6);
902 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
903 dev_info->cod = device_class;
904 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
905 event_data = dev_info;
906 size = sizeof(remote_device_t);
911 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
915 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
918 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
920 event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
922 BT_INFO("service_d: %d", service_d);
923 memcpy(auth_req->address.addr, bd_addr->address, 6);
924 auth_req->service_id = service_d;
926 send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
929 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
932 event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
934 if (trusted == BT_DEVICE_TRUSTED) {
935 BT_INFO("Device is Trusted");
936 event = OAL_EVENT_DEVICE_TRUSTED;
938 BT_INFO("Device is Un Trusted");
939 event = OAL_EVENT_DEVICE_UNTRUSTED;
941 memcpy(trust_val->address.addr, bd_addr->address, 6);
942 trust_val->status = OAL_STATUS_SUCCESS;
943 send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
947 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid, uint8_t *name, uint8_t *path, uint32_t fd)
949 event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
951 memcpy(auth_req->address.addr, bd_addr->address, 6);
952 memcpy(auth_req->uuid.uuid, uuid->uu, 16);
953 memcpy(auth_req->name, name, sizeof(auth_req->name) - 1);
954 memcpy(auth_req->path, path, sizeof(auth_req->path) - 1);
957 send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
960 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
962 event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
966 memcpy(ev->address.addr, bd_addr->address, 6);
967 ev->trust_val = trust_val;
968 send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
969 ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
973 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
975 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
976 oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
980 memcpy(ev->address.addr, bd_addr->address, 6);
981 ev->link_type = link_type;
983 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
985 send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
990 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
992 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
996 memcpy(ev->address.addr, bd_addr->address, 6);
997 ev->link_type = link_type;
998 ev->alert_type = alert_type;
1001 send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
1002 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
1006 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
1008 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
1012 memcpy(ev->address.addr, bd_addr->address, 6);
1013 ev->link_type = link_type;
1016 send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
1017 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
1021 void cb_dbfw_plus_info_received(unsigned char *data, uint32_t length, uint8_t event_code)
1023 event_dev_dbfw_plus_info_t *dbfw_info;
1024 int len = (length > 512)?512:length;
1026 ret_if(data == NULL || length == 0);
1028 dbfw_info = g_new0(event_dev_dbfw_plus_info_t, 1);
1029 dbfw_info->event_code = event_code;
1030 memcpy(dbfw_info->data, data, len);
1031 dbfw_info->length = len;
1033 send_event(OAL_EVENT_DEVICE_DBFW_PLUS_INFO,
1034 dbfw_info, sizeof(event_dev_dbfw_plus_info_t));