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, connection_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_accept_pin_request(bt_address_t * addr, const char * pin)
187 CHECK_OAL_INITIALIZED();
189 OAL_CHECK_PARAMETER(addr, return);
190 OAL_CHECK_PARAMETER(pin, return);
192 API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr), pin);
194 res = blued_api->pin_reply((bt_bdaddr_t *)addr, TRUE, strlen(pin), (bt_pin_code_t *)pin);
195 if (res != BT_STATUS_SUCCESS) {
196 BT_ERR("pin_reply error: [%s]", status2string(res));
197 BT_ERR("PIN: %s", pin);
198 return convert_to_oal_status(res);
201 return OAL_STATUS_SUCCESS;
204 oal_status_t device_reject_pin_request(bt_address_t * addr)
209 CHECK_OAL_INITIALIZED();
211 OAL_CHECK_PARAMETER(addr, return);
213 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
215 res = blued_api->pin_reply((bt_bdaddr_t *)addr, FALSE, 0, NULL);
216 if (res != BT_STATUS_SUCCESS) {
217 BT_ERR("pin_reply error: [%s]", status2string(res));
218 return convert_to_oal_status(res);
221 return OAL_STATUS_SUCCESS;
224 oal_status_t device_accept_passkey_entry(bt_address_t * addr, uint32_t passkey)
229 CHECK_OAL_INITIALIZED();
231 OAL_CHECK_PARAMETER(addr, return);
233 API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr), passkey);
235 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, TRUE, passkey);
236 if (res != BT_STATUS_SUCCESS) {
237 BT_ERR("ssp_reply error: [%s]", status2string(res));
238 BT_ERR("Passkey: %d", passkey);
239 return convert_to_oal_status(res);
243 return OAL_STATUS_SUCCESS;
246 oal_status_t device_reject_passkey_entry(bt_address_t * addr)
251 CHECK_OAL_INITIALIZED();
253 OAL_CHECK_PARAMETER(addr, return);
255 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
257 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, FALSE, 0);
258 if (res != BT_STATUS_SUCCESS) {
259 BT_ERR("ssp_reply error: [%s]", status2string(res));
260 return convert_to_oal_status(res);
263 return OAL_STATUS_SUCCESS;
266 oal_status_t device_reply_passkey_confirmation(bt_address_t * addr, int accept)
271 CHECK_OAL_INITIALIZED();
273 OAL_CHECK_PARAMETER(addr, return);
275 API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr), accept);
277 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_CONFIRMATION, accept, 0);
278 if (res != BT_STATUS_SUCCESS) {
279 BT_ERR("ssp_reply error: [%s]", status2string(res));
280 BT_ERR("%d", accept);
281 return convert_to_oal_status(res);
284 return OAL_STATUS_SUCCESS;
288 oal_status_t device_reply_ssp_consent(bt_address_t * addr, int accept)
293 CHECK_OAL_INITIALIZED();
295 OAL_CHECK_PARAMETER(addr, return);
297 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), accept);
299 res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_CONSENT, accept, 0);
300 if (res != BT_STATUS_SUCCESS) {
301 BT_ERR("ssp_reply error: [%s]", status2string(res));
302 BT_ERR("%d", accept);
303 return convert_to_oal_status(res);
306 return OAL_STATUS_SUCCESS;
309 oal_status_t device_reply_auth_request(bt_address_t * addr, oal_service_t service_type, int accept, int always)
314 CHECK_OAL_INITIALIZED();
316 OAL_CHECK_PARAMETER(addr, return);
318 API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr), accept, always, service_type);
320 res = blued_api->authorize_response((bt_bdaddr_t *)addr, service_type, accept, always);
321 if (res != BT_STATUS_SUCCESS) {
322 BT_ERR("authorize_response error: [%s]", status2string(res));
323 BT_ERR("Accept: [%d], always: [%d], service_type: [%d]", accept, always, service_type);
324 return convert_to_oal_status(res);
327 return OAL_STATUS_SUCCESS;
330 oal_status_t device_set_authorized(bt_address_t * addr, int authorize)
335 CHECK_OAL_INITIALIZED();
337 OAL_CHECK_PARAMETER(addr, return);
339 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), authorize);
341 res = blued_api->set_authorization((bt_bdaddr_t *)addr, authorize);
342 if (res != BT_STATUS_SUCCESS) {
343 BT_ERR("set_authorization error: [%s]", status2string(res));
344 BT_ERR("%d", authorize);
345 return convert_to_oal_status(res);
348 return OAL_STATUS_SUCCESS;
351 gboolean device_get_acl_conn_state(bt_address_t * addr)
356 CHECK_OAL_INITIALIZED();
357 OAL_CHECK_PARAMETER(addr, return);
359 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
361 res = blued_api->get_connection_state((bt_bdaddr_t *)addr);
362 BT_ERR("get_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
367 gboolean device_get_svc_conn_state(bt_address_t * addr, oal_service_t svc_id)
372 CHECK_OAL_INITIALIZED();
373 OAL_CHECK_PARAMETER(addr, return);
375 API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), svc_id);
378 res = blued_api->get_service_connection_state((bt_bdaddr_t *)addr, svc_id);
380 BT_ERR("Not supported");
383 BT_ERR("get_service_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
388 oal_status_t device_set_osp_server(oal_osp_server_type_e type, int enable)
391 uint32_t server_type;
393 CHECK_OAL_INITIALIZED();
395 API_TRACE("type: %d", type);
399 case OAL_OSP_SERVER_OBEX:
400 server_type = BT_OSP_SERVER_OBEX;
403 BT_ERR("unknown type: %d", type);
404 return OAL_STATUS_INVALID_PARAM;
407 res = blued_api->set_agent_osp_server(server_type, enable);
408 if (res != BT_STATUS_SUCCESS) {
409 BT_ERR("set_agent_osp_server error: [%s]", status2string(res));
410 return convert_to_oal_status(res);
413 return OAL_STATUS_SUCCESS;
415 BT_ERR("Not supported");
416 res = OAL_STATUS_NOT_SUPPORT;
421 oal_status_t device_set_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, gboolean trust)
426 CHECK_OAL_INITIALIZED();
428 OAL_CHECK_PARAMETER(addr, return);
430 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
433 res = blued_api->set_trusted_profile((bt_bdaddr_t *)addr, profile, (trust ? 1 : 0));
434 if (res != BT_STATUS_SUCCESS) {
435 BT_ERR("set_trusted_profile error: [%s]", status2string(res));
436 return convert_to_oal_status(res);
439 return OAL_STATUS_SUCCESS;
441 BT_ERR("Not supported");
442 res = OAL_STATUS_NOT_SUPPORT;
447 oal_status_t device_get_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, unsigned int *trusted)
452 CHECK_OAL_INITIALIZED();
454 OAL_CHECK_PARAMETER(addr, return);
456 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
459 res = blued_api->get_trusted_profile((bt_bdaddr_t *)addr, profile, trusted);
460 if (res != BT_STATUS_SUCCESS) {
461 BT_ERR("get_trusted_profile error: [%s]", status2string(res));
462 return convert_to_oal_status(res);
465 return OAL_STATUS_SUCCESS;
467 BT_ERR("Not supported");
468 res = OAL_STATUS_NOT_SUPPORT;
473 oal_status_t device_enable_rssi_monitoring(bt_address_t *addr, unsigned int link_type,
474 int low_threshold, int in_range_threshold, int high_threshold)
479 CHECK_OAL_INITIALIZED();
481 OAL_CHECK_PARAMETER(addr, return);
483 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
486 res = blued_api->enable_rssi_monitoring((bt_bdaddr_t *)addr, link_type,
487 low_threshold, in_range_threshold, high_threshold);
488 if (res != BT_STATUS_SUCCESS) {
489 BT_ERR("enable_rssi_monitoring error: [%s]", status2string(res));
490 return convert_to_oal_status(res);
493 return OAL_STATUS_SUCCESS;
495 BT_ERR("Not supported");
496 res = OAL_STATUS_NOT_SUPPORT;
501 oal_status_t device_get_connected_link_rssi_strength(bt_address_t *addr, unsigned int link_type)
506 CHECK_OAL_INITIALIZED();
508 OAL_CHECK_PARAMETER(addr, return);
510 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
513 res = blued_api->get_connected_link_rssi_strength((bt_bdaddr_t *)addr, link_type);
514 if (res != BT_STATUS_SUCCESS) {
515 BT_ERR("get_connected_link_rssi_strength error: [%s]", status2string(res));
516 return convert_to_oal_status(res);
519 return OAL_STATUS_SUCCESS;
521 BT_ERR("Not supported");
522 res = OAL_STATUS_NOT_SUPPORT;
527 oal_status_t device_enable_gap_auth_notifications(oal_gap_auth_type_e type, gboolean enable)
531 CHECK_OAL_INITIALIZED();
533 API_TRACE("type: [%d], enable: %d", type, enable);
536 res = blued_api->enable_gap_auth_notifications(type, (enable ? 1 : 0));
537 if (res != BT_STATUS_SUCCESS) {
538 BT_ERR("enable_gap_auth_notifications error: [%s]", status2string(res));
539 return convert_to_oal_status(res);
542 return OAL_STATUS_SUCCESS;
544 BT_ERR("Not supported");
545 res = OAL_STATUS_NOT_SUPPORT;
550 oal_status_t device_disconnect(bt_address_t * addr)
555 CHECK_OAL_INITIALIZED();
557 OAL_CHECK_PARAMETER(addr, return);
559 API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
561 res = blued_api->device_disconnect((bt_bdaddr_t *)addr);
562 if (res != BT_STATUS_SUCCESS) {
563 BT_ERR("device_disconnect error: [%s]", status2string(res));
564 return convert_to_oal_status(res);
567 return OAL_STATUS_SUCCESS;
570 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
571 int num_properties, bt_property_t *properties)
574 gpointer event_data = NULL;
575 remote_device_t *dev_info;
576 ble_adv_data_t adv_info;
580 BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
581 status, num_properties);
583 dev_info = g_new0(remote_device_t, 1);
584 memcpy(dev_info->address.addr, bd_addr->address, 6);
585 parse_device_properties(num_properties, properties, dev_info, &adv_info);
587 if (num_properties == 0) {
588 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
589 /* It is possible that app called get bonded device info for a device
590 which is not yet bonded or udner bonding, in such case, stack will return no properties.
591 It is also possible that after bonding is done, BT MW attempted to fetch
592 bonded device info, but due to internal stack error, 0 properties with status FAIL
593 are received from stack. In such cases, simply send the event to BT MW
594 and let it handle this event */
595 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
596 memcpy(&dev_props_event->device_info,
597 dev_info, sizeof(remote_device_t));
598 event_data = dev_props_event;
599 event = OAL_EVENT_DEVICE_PROPERTIES;
600 size = sizeof(event_dev_properties_t);
602 } else if (num_properties == 1) {
603 /* For one particular property a dedicated event to be sent */
604 switch (properties[0].type) {
605 case BT_PROPERTY_BDNAME:
606 event = OAL_EVENT_DEVICE_NAME;
607 event_data = dev_info;
608 send_event_trace(event, event_data, sizeof(remote_device_t),
609 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
611 case BT_PROPERTY_UUIDS: {
612 event_dev_services_t *services_info;
613 bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
614 BT_INFO("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
616 services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
617 services_info->address = dev_info->address;
618 memcpy(services_info->service_list, uuids, properties[0].len);
619 services_info->num = properties[0].len/sizeof(bt_uuid_t);
620 BT_INFO("Number of UUID [%d]", services_info->num);
621 event = OAL_EVENT_DEVICE_SERVICES;
622 event_data = services_info;
623 size = sizeof(event_dev_services_t) + properties[0].len;
628 BT_ERR("Single Property [%d] not handled", properties[0].type);
633 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
634 if (dev_info->type != DEV_TYPE_BREDR) {
637 BT_INFO("BLE Device");
638 /* BLE Single or DUAL mode found, so it should have Adv data */
639 dev_props_event->adv_len = adv_info.len;
640 if (dev_props_event->adv_len > 0)
641 memcpy(dev_props_event->adv_data,
642 adv_info.adv_data, adv_info.len);
644 for (i = 0; i < dev_props_event->adv_len; i++)
645 BT_INFO("Adv Data[%d] = [0x%x]",
646 i, dev_props_event->adv_data[i]);
647 memcpy(&dev_props_event->device_info,
648 dev_info, sizeof(remote_device_t));
650 BT_INFO("BREDR type Device");
651 memcpy(&dev_props_event->device_info,
652 dev_info, sizeof(remote_device_t));
655 event_data = dev_props_event;
656 event = OAL_EVENT_DEVICE_PROPERTIES;
657 size = sizeof(event_dev_properties_t);
661 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
664 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
665 bt_bond_state_t state)
667 bt_address_t * address = g_new0(bt_address_t, 1);
671 BT_DBG("status: %d, state: %d", status, state);
673 memcpy(address->addr, bd_addr->address, 6);
676 case BT_BOND_STATE_BONDED:
677 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
679 case BT_BOND_STATE_NONE:
680 /* Reaches both when bonding removed or bonding cancelled */
681 if (BT_STATUS_SUCCESS != status) {
682 event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
683 bond_fail_info->status = convert_to_oal_status(status);
684 bond_fail_info->address = *address;
685 size = sizeof(event_dev_bond_failed_t);
686 send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
690 event = OAL_EVENT_DEVICE_BONDING_REMOVED;
692 case BT_BOND_STATE_BONDING:
696 BT_ERR("Unexpected Bond state %d", state);
700 send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
703 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
704 bt_acl_state_t state)
706 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
707 //bt_address_t * address = g_new0(bt_address_t, 1);
711 BT_DBG("ACL State:%d, state: %d", status, state);
713 memcpy(conn_status->address.addr, bd_addr->address, 6);
716 conn_status->status = convert_to_oal_status(status);
718 if (BT_STATUS_SUCCESS != status) {
719 /* At present only timeout will cause non-success status, later we can add more */
720 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
721 BT_ERR("ACL State Error:%d, state: %d", status, state);
723 conn_status->status = OAL_STATUS_SUCCESS;
725 memcpy(conn_status->address.addr, bd_addr->address, 6);
728 BT_INFO("ACL STATE :%d, conn_status->status :%d, BT_ACL_STATE: %d", status, conn_status->status, state);
731 case BT_ACL_STATE_CONNECTED:
732 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
733 conn_status->status = OAL_STATUS_SUCCESS;
735 case BT_ACL_STATE_DISCONNECTED:
736 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
739 BT_ERR("Unexpected ACL state %d", state);
744 size = sizeof(event_dev_conn_status_t);
745 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
749 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
750 bt_le_conn_state_t state)
752 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
753 //bt_address_t * address = g_new0(bt_address_t, 1);
757 BT_DBG("LE conn status:%d, state: %d", status, state);
758 memcpy(conn_status->address.addr, bd_addr->address, 6);
759 conn_status->status = convert_to_oal_status(status);
762 case BT_LE_CONN_STATE_CONNECTED:
763 event = OAL_EVENT_DEVICE_LE_CONNECTED;
765 case BT_LE_CONN_STATE_DISCONNECTED:
766 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
769 BT_ERR("Unexpected ACL state %d", state);
774 size = sizeof(event_dev_conn_status_t);
775 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
779 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
781 remote_device_t * dev_info = g_new0(remote_device_t, 1);
785 memcpy(dev_info->address.addr, bd_addr->address, 6);
786 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
787 dev_info->cod = device_class;
788 size = sizeof(remote_device_t);
790 send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
793 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
794 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
797 gpointer event_data = NULL;
801 switch (pairing_variant) {
802 case BT_SSP_VARIANT_PASSKEY_ENTRY:
804 remote_device_t * dev_info = g_new0(remote_device_t, 1);
805 memcpy(dev_info->address.addr, bd_addr->address, 6);
806 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
807 dev_info->cod = device_class;
808 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
809 event_data = dev_info;
810 size = sizeof(remote_device_t);
813 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
815 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
817 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
818 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
819 passkey_data->device_info.cod = device_class;
820 passkey_data->pass_key = pass_key;
821 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
822 event_data = passkey_data;
823 size = sizeof(event_dev_passkey_t);
826 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
828 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
830 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
831 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
832 passkey_data->device_info.cod = device_class;
833 passkey_data->pass_key = pass_key;
834 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
835 event_data = passkey_data;
836 size = sizeof(event_dev_passkey_t);
839 case BT_SSP_VARIANT_CONSENT:
841 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 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
847 event_data = dev_info;
848 size = sizeof(remote_device_t);
853 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
857 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
860 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
862 event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
864 BT_INFO("service_d: %d", service_d);
865 memcpy(auth_req->address.addr, bd_addr->address, 6);
866 auth_req->service_id = service_d;
868 send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
871 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
874 event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
876 if (trusted == BT_DEVICE_TRUSTED) {
877 BT_INFO("Device is Trusted");
878 event = OAL_EVENT_DEVICE_TRUSTED;
880 BT_INFO("Device is Un Trusted");
881 event = OAL_EVENT_DEVICE_UNTRUSTED;
883 memcpy(trust_val->address.addr, bd_addr->address, 6);
884 trust_val->status = OAL_STATUS_SUCCESS;
885 send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
889 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid)
891 event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
893 memcpy(auth_req->address.addr, bd_addr->address, 6);
894 memcpy(auth_req->uuid.uuid, uuid->uu, 16);
896 send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
899 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
901 event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
905 memcpy(ev->address.addr, bd_addr->address, 6);
906 ev->trust_val = trust_val;
907 send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
908 ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
912 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
914 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
915 oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
919 memcpy(ev->address.addr, bd_addr->address, 6);
920 ev->link_type = link_type;
922 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
924 send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
929 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
931 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
935 memcpy(ev->address.addr, bd_addr->address, 6);
936 ev->link_type = link_type;
937 ev->alert_type = alert_type;
940 send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
941 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
945 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
947 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
951 memcpy(ev->address.addr, bd_addr->address, 6);
952 ev->link_type = link_type;
955 send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
956 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);