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 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
551 int num_properties, bt_property_t *properties)
554 gpointer event_data = NULL;
555 remote_device_t *dev_info;
556 ble_adv_data_t adv_info;
560 BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
561 status, num_properties);
563 dev_info = g_new0(remote_device_t, 1);
564 memcpy(dev_info->address.addr, bd_addr->address, 6);
565 parse_device_properties(num_properties, properties, dev_info, &adv_info);
567 if (num_properties == 0) {
568 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
569 /* It is possible that app called get bonded device info for a device
570 which is not yet bonded or udner bonding, in such case, stack will return no properties.
571 It is also possible that after bonding is done, BT MW attempted to fetch
572 bonded device info, but due to internal stack error, 0 properties with status FAIL
573 are received from stack. In such cases, simply send the event to BT MW
574 and let it handle this event */
575 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
576 memcpy(&dev_props_event->device_info,
577 dev_info, sizeof(remote_device_t));
578 event_data = dev_props_event;
579 event = OAL_EVENT_DEVICE_PROPERTIES;
580 size = sizeof(event_dev_properties_t);
581 } else if (num_properties == 1) {
582 /* For one particular property a dedicated event to be sent */
583 switch (properties[0].type) {
584 case BT_PROPERTY_BDNAME:
585 event = OAL_EVENT_DEVICE_NAME;
586 event_data = dev_info;
587 send_event_trace(event, event_data, sizeof(remote_device_t),
588 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
590 case BT_PROPERTY_UUIDS: {
591 event_dev_services_t *services_info;
592 bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
593 BT_INFO("Properties len [%d] event structure size [%d]", properties[0].len, sizeof(event_dev_services_t));
595 services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
596 services_info->address = dev_info->address;
597 memcpy(services_info->service_list, uuids, properties[0].len);
598 services_info->num = properties[0].len/sizeof(bt_uuid_t);
599 BT_INFO("Number of UUID [%d]", services_info->num);
600 event = OAL_EVENT_DEVICE_SERVICES;
601 event_data = services_info;
602 size = sizeof(event_dev_services_t) + properties[0].len;
607 BT_ERR("Single Property [%d] not handled", properties[0].type);
612 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
613 if (dev_info->type != DEV_TYPE_BREDR) {
616 BT_INFO("BLE Device");
617 /* BLE Single or DUAL mode found, so it should have Adv data */
618 dev_props_event->adv_len = adv_info.len;
619 if (dev_props_event->adv_len > 0)
620 memcpy(dev_props_event->adv_data,
621 adv_info.adv_data, adv_info.len);
623 for (i = 0; i < dev_props_event->adv_len; i++)
624 BT_INFO("Adv Data[%d] = [0x%x]",
625 i, dev_props_event->adv_data[i]);
626 memcpy(&dev_props_event->device_info,
627 dev_info, sizeof(remote_device_t));
629 BT_INFO("BREDR type Device");
630 memcpy(&dev_props_event->device_info,
631 dev_info, sizeof(remote_device_t));
634 event_data = dev_props_event;
635 event = OAL_EVENT_DEVICE_PROPERTIES;
636 size = sizeof(event_dev_properties_t);
639 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
642 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
643 bt_bond_state_t state)
645 bt_address_t * address = g_new0(bt_address_t, 1);
649 BT_DBG("status: %d, state: %d", status, state);
651 memcpy(address->addr, bd_addr->address, 6);
654 case BT_BOND_STATE_BONDED:
655 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
657 case BT_BOND_STATE_NONE:
658 /* Reaches both when bonding removed or bonding cancelled */
659 if (BT_STATUS_SUCCESS != status) {
660 event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
661 bond_fail_info->status = convert_to_oal_status(status);
662 bond_fail_info->address = *address;
663 size = sizeof(event_dev_bond_failed_t);
664 send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
668 event = OAL_EVENT_DEVICE_BONDING_REMOVED;
670 case BT_BOND_STATE_BONDING:
674 BT_ERR("Unexpected Bond state %d", state);
678 send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
681 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
682 bt_acl_state_t state)
684 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
685 //bt_address_t * address = g_new0(bt_address_t, 1);
689 BT_DBG("ACL State:%d, state: %d", status, state);
691 memcpy(conn_status->address.addr, bd_addr->address, 6);
693 if (BT_STATUS_SUCCESS != status) {
694 /* At present only timeout will cause non-success status, later we can add more */
695 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
696 BT_ERR("ACL State Error:%d, state: %d", status, state);
698 conn_status->status = OAL_STATUS_SUCCESS;
700 memcpy(conn_status->address.addr, bd_addr->address, 6);
702 case BT_ACL_STATE_CONNECTED:
703 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
704 conn_status->status = OAL_STATUS_SUCCESS;
706 case BT_ACL_STATE_DISCONNECTED:
707 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
710 BT_ERR("Unexpected ACL state %d", state);
715 size = sizeof(event_dev_conn_status_t);
716 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
720 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
721 bt_le_conn_state_t state)
723 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
724 //bt_address_t * address = g_new0(bt_address_t, 1);
728 BT_DBG("LE conn status:%d, state: %d", status, state);
729 memcpy(conn_status->address.addr, bd_addr->address, 6);
730 if (BT_STATUS_SUCCESS != status)
731 /* At present only timeout will cause non-success status, later we can add more */
732 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
734 conn_status->status = OAL_STATUS_SUCCESS;
737 case BT_LE_CONN_STATE_CONNECTED:
738 event = OAL_EVENT_DEVICE_LE_CONNECTED;
740 case BT_LE_CONN_STATE_DISCONNECTED:
741 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
744 BT_ERR("Unexpected ACL state %d", state);
749 size = sizeof(event_dev_conn_status_t);
750 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
754 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
756 remote_device_t * dev_info = g_new0(remote_device_t, 1);
760 memcpy(dev_info->address.addr, bd_addr->address, 6);
761 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
762 dev_info->cod = device_class;
763 size = sizeof(remote_device_t);
765 send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
768 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
769 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
772 gpointer event_data = NULL;
776 switch (pairing_variant) {
777 case BT_SSP_VARIANT_PASSKEY_ENTRY:
779 remote_device_t * dev_info = g_new0(remote_device_t, 1);
780 memcpy(dev_info->address.addr, bd_addr->address, 6);
781 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
782 dev_info->cod = device_class;
783 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
784 event_data = dev_info;
785 size = sizeof(remote_device_t);
788 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
790 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
792 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
793 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
794 passkey_data->device_info.cod = device_class;
795 passkey_data->pass_key = pass_key;
796 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
797 event_data = passkey_data;
798 size = sizeof(event_dev_passkey_t);
801 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
803 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
805 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
806 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
807 passkey_data->device_info.cod = device_class;
808 passkey_data->pass_key = pass_key;
809 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
810 event_data = passkey_data;
811 size = sizeof(event_dev_passkey_t);
814 case BT_SSP_VARIANT_CONSENT:
816 remote_device_t * dev_info = g_new0(remote_device_t, 1);
818 memcpy(dev_info->address.addr, bd_addr->address, 6);
819 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
820 dev_info->cod = device_class;
821 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
822 event_data = dev_info;
823 size = sizeof(remote_device_t);
828 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
832 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
835 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
837 event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
839 BT_INFO("service_d: %d", service_d);
840 memcpy(auth_req->address.addr, bd_addr->address, 6);
841 auth_req->service_id = service_d;
843 send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
846 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
849 event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
851 if (trusted == BT_DEVICE_TRUSTED) {
852 BT_INFO("Device is Trusted");
853 event = OAL_EVENT_DEVICE_TRUSTED;
855 BT_INFO("Device is Un Trusted");
856 event = OAL_EVENT_DEVICE_UNTRUSTED;
858 memcpy(trust_val->address.addr, bd_addr->address, 6);
859 trust_val->status = OAL_STATUS_SUCCESS;
860 send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
864 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid)
866 event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
868 memcpy(auth_req->address.addr, bd_addr->address, 6);
869 memcpy(auth_req->uuid.uuid, uuid->uu, 16);
871 send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
874 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
876 event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
880 memcpy(ev->address.addr, bd_addr->address, 6);
881 ev->trust_val = trust_val;
882 send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
883 ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
887 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
889 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
890 oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
894 memcpy(ev->address.addr, bd_addr->address, 6);
895 ev->link_type = link_type;
897 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
899 send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
904 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
906 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
910 memcpy(ev->address.addr, bd_addr->address, 6);
911 ev->link_type = link_type;
912 ev->alert_type = alert_type;
915 send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
916 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
920 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
922 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
926 memcpy(ev->address.addr, bd_addr->address, 6);
927 ev->link_type = link_type;
930 send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
931 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);