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);
582 } else if (num_properties == 1) {
583 /* For one particular property a dedicated event to be sent */
584 switch (properties[0].type) {
585 case BT_PROPERTY_BDNAME:
586 event = OAL_EVENT_DEVICE_NAME;
587 event_data = dev_info;
588 send_event_trace(event, event_data, sizeof(remote_device_t),
589 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
591 case BT_PROPERTY_UUIDS: {
592 event_dev_services_t *services_info;
593 bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
594 BT_INFO("Properties len [%d] event structure size [%d]", properties[0].len, sizeof(event_dev_services_t));
596 services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
597 services_info->address = dev_info->address;
598 memcpy(services_info->service_list, uuids, properties[0].len);
599 services_info->num = properties[0].len/sizeof(bt_uuid_t);
600 BT_INFO("Number of UUID [%d]", services_info->num);
601 event = OAL_EVENT_DEVICE_SERVICES;
602 event_data = services_info;
603 size = sizeof(event_dev_services_t) + properties[0].len;
608 BT_ERR("Single Property [%d] not handled", properties[0].type);
613 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
614 if (dev_info->type != DEV_TYPE_BREDR) {
617 BT_INFO("BLE Device");
618 /* BLE Single or DUAL mode found, so it should have Adv data */
619 dev_props_event->adv_len = adv_info.len;
620 if (dev_props_event->adv_len > 0)
621 memcpy(dev_props_event->adv_data,
622 adv_info.adv_data, adv_info.len);
624 for (i = 0; i < dev_props_event->adv_len; i++)
625 BT_INFO("Adv Data[%d] = [0x%x]",
626 i, dev_props_event->adv_data[i]);
627 memcpy(&dev_props_event->device_info,
628 dev_info, sizeof(remote_device_t));
630 BT_INFO("BREDR type Device");
631 memcpy(&dev_props_event->device_info,
632 dev_info, sizeof(remote_device_t));
635 event_data = dev_props_event;
636 event = OAL_EVENT_DEVICE_PROPERTIES;
637 size = sizeof(event_dev_properties_t);
641 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
644 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
645 bt_bond_state_t state)
647 bt_address_t * address = g_new0(bt_address_t, 1);
651 BT_DBG("status: %d, state: %d", status, state);
653 memcpy(address->addr, bd_addr->address, 6);
656 case BT_BOND_STATE_BONDED:
657 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
659 case BT_BOND_STATE_NONE:
660 /* Reaches both when bonding removed or bonding cancelled */
661 if (BT_STATUS_SUCCESS != status) {
662 event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
663 bond_fail_info->status = convert_to_oal_status(status);
664 bond_fail_info->address = *address;
665 size = sizeof(event_dev_bond_failed_t);
666 send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
670 event = OAL_EVENT_DEVICE_BONDING_REMOVED;
672 case BT_BOND_STATE_BONDING:
676 BT_ERR("Unexpected Bond state %d", state);
680 send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
683 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
684 bt_acl_state_t state)
686 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
687 //bt_address_t * address = g_new0(bt_address_t, 1);
691 BT_DBG("ACL State:%d, state: %d", status, state);
693 memcpy(conn_status->address.addr, bd_addr->address, 6);
695 if (BT_STATUS_SUCCESS != status) {
696 /* At present only timeout will cause non-success status, later we can add more */
697 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
698 BT_ERR("ACL State Error:%d, state: %d", status, state);
700 conn_status->status = OAL_STATUS_SUCCESS;
702 memcpy(conn_status->address.addr, bd_addr->address, 6);
704 case BT_ACL_STATE_CONNECTED:
705 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
706 conn_status->status = OAL_STATUS_SUCCESS;
708 case BT_ACL_STATE_DISCONNECTED:
709 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
712 BT_ERR("Unexpected ACL state %d", state);
717 size = sizeof(event_dev_conn_status_t);
718 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
722 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
723 bt_le_conn_state_t state)
725 event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
726 //bt_address_t * address = g_new0(bt_address_t, 1);
730 BT_DBG("LE conn status:%d, state: %d", status, state);
731 memcpy(conn_status->address.addr, bd_addr->address, 6);
732 if (BT_STATUS_SUCCESS != status)
733 /* At present only timeout will cause non-success status, later we can add more */
734 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
736 conn_status->status = OAL_STATUS_SUCCESS;
739 case BT_LE_CONN_STATE_CONNECTED:
740 event = OAL_EVENT_DEVICE_LE_CONNECTED;
742 case BT_LE_CONN_STATE_DISCONNECTED:
743 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
746 BT_ERR("Unexpected ACL state %d", state);
751 size = sizeof(event_dev_conn_status_t);
752 send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
756 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
758 remote_device_t * dev_info = g_new0(remote_device_t, 1);
762 memcpy(dev_info->address.addr, bd_addr->address, 6);
763 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
764 dev_info->cod = device_class;
765 size = sizeof(remote_device_t);
767 send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
770 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
771 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
774 gpointer event_data = NULL;
778 switch (pairing_variant) {
779 case BT_SSP_VARIANT_PASSKEY_ENTRY:
781 remote_device_t * dev_info = g_new0(remote_device_t, 1);
782 memcpy(dev_info->address.addr, bd_addr->address, 6);
783 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
784 dev_info->cod = device_class;
785 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
786 event_data = dev_info;
787 size = sizeof(remote_device_t);
790 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
792 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
794 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
795 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
796 passkey_data->device_info.cod = device_class;
797 passkey_data->pass_key = pass_key;
798 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
799 event_data = passkey_data;
800 size = sizeof(event_dev_passkey_t);
803 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
805 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
807 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
808 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
809 passkey_data->device_info.cod = device_class;
810 passkey_data->pass_key = pass_key;
811 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
812 event_data = passkey_data;
813 size = sizeof(event_dev_passkey_t);
816 case BT_SSP_VARIANT_CONSENT:
818 remote_device_t * dev_info = g_new0(remote_device_t, 1);
820 memcpy(dev_info->address.addr, bd_addr->address, 6);
821 g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
822 dev_info->cod = device_class;
823 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
824 event_data = dev_info;
825 size = sizeof(remote_device_t);
830 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
834 send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
837 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
839 event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
841 BT_INFO("service_d: %d", service_d);
842 memcpy(auth_req->address.addr, bd_addr->address, 6);
843 auth_req->service_id = service_d;
845 send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
848 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
851 event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
853 if (trusted == BT_DEVICE_TRUSTED) {
854 BT_INFO("Device is Trusted");
855 event = OAL_EVENT_DEVICE_TRUSTED;
857 BT_INFO("Device is Un Trusted");
858 event = OAL_EVENT_DEVICE_UNTRUSTED;
860 memcpy(trust_val->address.addr, bd_addr->address, 6);
861 trust_val->status = OAL_STATUS_SUCCESS;
862 send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
866 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid)
868 event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
870 memcpy(auth_req->address.addr, bd_addr->address, 6);
871 memcpy(auth_req->uuid.uuid, uuid->uu, 16);
873 send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
876 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
878 event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
882 memcpy(ev->address.addr, bd_addr->address, 6);
883 ev->trust_val = trust_val;
884 send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
885 ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
889 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
891 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
892 oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
896 memcpy(ev->address.addr, bd_addr->address, 6);
897 ev->link_type = link_type;
899 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
901 send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
906 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
908 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
912 memcpy(ev->address.addr, bd_addr->address, 6);
913 ev->link_type = link_type;
914 ev->alert_type = alert_type;
917 send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
918 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
922 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
924 event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
928 memcpy(ev->address.addr, bd_addr->address, 6);
929 ev->link_type = link_type;
932 send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
933 ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);