bt_uuid_t uuid;
} hal_gatt_desc_added;
+
+struct hal_gatts_server_register_info_t {
+ int server_if;
+ int adv_slot_id;
+ bt_uuid_t app_uuid;
+};
+
+static GSList * hal_gatts_server_register_list;
+
+
+/* Should match the range with bt-service-gatt.c's MAX_APPS_SUPPORTED */
+/* TODO: Adjust MAX Server after modifying MAX app handle logic */
+#define BT_GATTS_MAX 11
+
+static int assigned_id = 0;
+
+static gboolean instance_id_used[BT_GATTS_MAX];
+
#define CHECK_BTGATT_INIT() if (bt_gatt_callbacks == NULL)\
{\
ERR("%s: BTGATT not initialized", __FUNCTION__);\
static GDBusProxy *__bt_gatt_gdbus_get_gatt_manager_proxy(const gchar *service,
const gchar *path, const gchar *interface);
+static int bt_hal_gatts_get_gatt_server_instance();
+
/* Introspection data for the service we are exporting */
static const gchar service_introspection_xml[] =
"<node name='/'>"
" </interface>"
"</node>";
-GSList *_bt_get_service_list_from_server(int instance)
+void _bt_hal_gatt_server_init(void)
+{
+ assigned_id = 0;
+ memset(instance_id_used, 0x00, sizeof(instance_id_used));
+}
+
+static int __bt_hal_gatt_assign_id(void)
+{
+ int index;
+
+ index = assigned_id + 1;
+
+ if (index >= BT_GATTS_MAX)
+ index = 1;
+
+ while (instance_id_used[index] == TRUE) {
+ if (index == assigned_id) {
+ /* No available ID */
+ ERR("All interface ID is used");
+ return -1;
+ }
+
+ index++;
+
+ if (index >= BT_GATTS_MAX)
+ index = 1;
+ }
+
+ assigned_id = index;
+ instance_id_used[index] = TRUE;
+
+ return assigned_id;
+}
+
+static void __bt_hal_gatt_delete_id(int instance_id)
+{
+ if (instance_id >= BT_GATTS_MAX || instance_id < 0)
+ return;
+
+ instance_id_used[instance_id] = FALSE;
+}
+
+static GSList *_bt_get_service_list_from_server(int instance)
{
GSList *l;
INFO("Number of GATT Server apps [%d]", g_slist_length(gatt_server_apps));
return NULL;
}
-void _bt_remote_service_from_gatt_server(int instance, int service_handle)
+static void _bt_remote_service_from_gatt_server(int instance, int service_handle)
{
GSList *l;
GSList *l1;
}
}
-void _bt_hal_update_gatt_service_in_gatt_server(int slot, struct gatt_service_info *serv_info)
+static void _bt_hal_update_gatt_service_in_gatt_server(int slot, struct gatt_service_info *serv_info)
{
GSList *l;
for (l = gatt_server_apps; l; l = g_slist_next(l)) {
}
}
+int _bt_get_remote_gatt_client_conn_id(char *address)
+{
+ GSList *l;
+ struct gatt_client_info_t *info = NULL;
+
+ for (l = gatt_client_info_list; l != NULL; l = g_slist_next(l)) {
+ info = (struct gatt_client_info_t*)l->data;
+ if (info == NULL)
+ continue;
+
+ if (!g_strcmp0(info->addr, address)) {
+ INFO("Remote GATT client found addr[%s]", info->addr);
+ return info->connection_id;
+ }
+ }
+ return 0;
+}
+
static struct gatt_client_info_t *__bt_find_remote_gatt_client_info(char *address)
{
GSList *l;
memset(&ev, 0, sizeof(ev));
/* Find Server Instance */
- _bt_hal_get_gatt_server_instance_initialized(&instance);
+ instance = bt_hal_gatts_get_gatt_server_instance();
if (instance == -1) {
ERR("Not even a single GATT server is registered");
return;
}
+ DBG("server instance [%d]", instance);
+
/* Convert address to hex */
_bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
return NULL;
}
-char *__bt_gatt_find_char_path_from_handle(int char_hdl)
+static char *__bt_gatt_find_char_path_from_handle(int char_hdl)
{
GSList *l1, *l2;
return NULL;
}
-struct gatt_char_info *__bt_gatt_find_char_info_from_handle(int char_hdl)
+static struct gatt_char_info *__bt_gatt_find_char_info_from_handle(int char_hdl)
{
GSList *l1, *l2;
for (i = 0; i < char_info->flags_length; i++) {
g_variant_builder_add(builder2, "s",
char_info->char_flags[i]);
- if (strncmp(char_info->char_flags[i], "write-without-response", 16) == 0)
+
+ if (strncmp(char_info->char_flags[i], "write-without-response", 16) == 0) {
+ DBG("setting WriteAcquired property");
writeAcquired = TRUE;
+ }
- if (strncmp(char_info->char_flags[i], "notify", 4) == 0)
+ if (strncmp(char_info->char_flags[i], "notify", 4) == 0) {
+ DBG("setting NotifyAcquired property");
notifyAcquired = TRUE;
+ }
}
flags_val = g_variant_new("as", builder2);
g_variant_builder_add(inner_builder, "{sv}", "Notifying",
g_variant_new("b", notify));
- /* Unicast */
- g_variant_builder_add(inner_builder, "{sv}", "WriteAcquired",
+ /* WriteAcquired */
+ if (writeAcquired == TRUE) {
+ DBG("adding WriteAcquired property");
+ g_variant_builder_add(inner_builder, "{sv}", "WriteAcquired",
g_variant_new("b", writeAcquired));
+ }
/* NotifyAcquired */
- g_variant_builder_add(inner_builder, "{sv}", "NotifyAcquired",
- g_variant_new("b", notifyAcquired));
+ if (notifyAcquired == TRUE) {
+ DBG("adding NotifyAcquired property");
+ g_variant_builder_add(inner_builder, "{sv}", "NotifyAcquired",
+ g_variant_new("b", notifyAcquired));
+ }
/* Unicast */
unicast = g_strdup("00:00:00:00:00:00");
req_info->attr_path = g_strdup(object_path);
req_info->svc_path = g_strdup(svc_info->serv_path);
req_info->request_id = req_id;
+ req_info->request_type = BT_HAL_GATT_REQUEST_TYPE_READ;
req_info->offset = offset;
req_info->context = invocation;
req_info->attr_path = g_strdup(object_path);
req_info->svc_path = g_strdup(svc_info->serv_path);
req_info->request_id = req_id;
+ req_info->request_type = BT_HAL_GATT_REQUEST_TYPE_WRITE;
req_info->offset = offset;
req_info->context = invocation;
g_dbus_method_invocation_return_value(invocation, NULL);
}
-gboolean __bt_hal_gatt_emit_interface_removed(gchar *object_path, gchar *interface)
+static gboolean __bt_hal_gatt_emit_interface_removed(gchar *object_path, gchar *interface)
{
gboolean ret;
GError *error = NULL;
return FALSE;
}
+
+static int bt_hal_gatts_get_gatt_server_instance()
+{
+ DBG("+");
+
+ GSList *l;
+ struct hal_gatts_server_register_info_t *info = NULL;
+
+ for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+ info = (struct hal_gatts_server_register_info_t *)l->data;
+ if (info == NULL) {
+ continue;
+ }
+
+ return info->server_if;
+ }
+
+ return -1;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_find_server_register_info_from_uuid(bt_uuid_t *app_uuid)
+{
+ DBG("+");
+
+ GSList *l;
+ struct hal_gatts_server_register_info_t *info = NULL;
+
+ for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+ info = (struct hal_gatts_server_register_info_t *)l->data;
+ if (info == NULL) {
+ continue;
+ }
+
+ if (memcmp(&info->app_uuid, app_uuid, sizeof(bt_uuid_t)) == 0) {
+ DBG("gatt server register found");
+ return info;
+ }
+ }
+
+ return NULL;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_find_server_register_info(int server_if)
+{
+ GSList *l;
+ struct hal_gatts_server_register_info_t *info = NULL;
+
+ for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+ info = (struct hal_gatts_server_register_info_t *)l->data;
+ if (info == NULL) {
+ continue;
+ }
+
+ if (info->server_if == server_if) {
+ return info;
+ }
+ }
+
+ return NULL;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_find_server_register_info_by_slot_id(int adv_slot_id)
+{
+ DBG("+");
+
+ GSList *l;
+ struct hal_gatts_server_register_info_t *info = NULL;
+
+ for (l = hal_gatts_server_register_list; l != NULL; l = g_slist_next(l)) {
+ info = (struct hal_gatts_server_register_info_t *)l->data;
+ if (info == NULL) {
+ continue;
+ }
+
+ if (info->adv_slot_id == adv_slot_id) {
+ DBG("gatt server register found");
+ return info;
+ }
+ }
+
+ return NULL;
+}
+
+static struct hal_gatts_server_register_info_t * bt_hal_gatts_add_server_app(bt_uuid_t *app_uuid)
+{
+ struct hal_gatts_server_register_info_t * server_register_info = NULL;
+ int instance_id = 0;
+
+ server_register_info = bt_hal_gatts_find_server_register_info_from_uuid(app_uuid);
+ if (server_register_info != NULL) {
+ DBG("gatt server is already registered");
+ return server_register_info;
+ }
+
+ instance_id = __bt_hal_gatt_assign_id();
+ if (instance_id == -1) {
+ ERR("Fail to allocate the server if");
+ return NULL;
+ }
+
+ server_register_info = g_malloc0(sizeof(struct hal_gatts_server_register_info_t));
+ server_register_info->server_if = instance_id;
+
+ DBG("Adding the gatt server app. server_if:[%d]", server_register_info->server_if);
+
+ server_register_info->adv_slot_id = -1;
+ memcpy(&server_register_info->app_uuid, app_uuid, sizeof(bt_uuid_t));
+ hal_gatts_server_register_list = g_slist_append(hal_gatts_server_register_list, server_register_info);
+
+ return server_register_info;
+}
+
static bt_status_t gatt_server_register_app(bt_uuid_t *uuid)
{
CHECK_BTGATT_INIT();
- int status = BT_STATUS_FAIL;
- int server_if;
- DBG("Register server instance request");
- hal_register_server_data *user_data = g_malloc0(sizeof(hal_register_server_data));
-
- /* Check if slot available */
- server_if = _bt_hal_get_available_adv_slot_id(uuid);
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
- if (server_if == -1) {
- ERR("Allocation of server instance failed");
- g_free(user_data);
- return status;
- } else {
- user_data->instance_data = server_if;
- DBG("Allocated new Advertising slot with Stack [%d]", user_data->instance_data);
+ DBG("Register server instance request");
+ server_register_info = bt_hal_gatts_add_server_app(uuid);
+ if (server_register_info == NULL) {
+ ERR("Fail to register the server app");
+ return BT_STATUS_FAIL;
}
+ hal_register_server_data *user_data = g_malloc0(sizeof(hal_register_server_data));
+ user_data->instance_data = server_register_info->server_if;
+
/*
* As we need to provide async callback to user from HAL, simply schedule a
* callback method which will carry actual result
return BT_STATUS_SUCCESS;
}
-void _bt_hal_remove_gatt_server_from_list(int server_if)
+static void _bt_hal_remove_gatt_server_from_list(int server_if)
{
GSList *l;
struct gatt_server_app *info = NULL;
{
CHECK_BTGATT_INIT();
DBG("Un-Register server instance request [%d]", server_if);
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
- if (_bt_hal_is_advertising_in_slot(server_if) == FALSE)
- _bt_hal_free_server_slot(server_if);
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ DBG("gatt server is not registered");
+ return BT_STATUS_SUCCESS;
+ }
+
+ /* remove the gatt server register info from the register list */
+ hal_gatts_server_register_list = g_slist_remove(hal_gatts_server_register_list, server_register_info);
+ g_free(server_register_info);
+
+ __bt_hal_gatt_delete_id(server_if);
/* If server_if belongs to a GATT Server, then delete the GATT server from List */
_bt_hal_remove_gatt_server_from_list(server_if);
return BT_STATUS_SUCCESS;
}
-static void __bt_gatt_close_gdbus_connection(void)
-{
- GError *err = NULL;
- DBG("+");
-
- if (g_conn == NULL)
- return;
-
- if (!g_dbus_connection_flush_sync(g_conn, NULL, &err)) {
- ERR("Fail to flush the connection: %s", err->message);
- g_error_free(err);
- err = NULL;
- }
-
- if (!g_dbus_connection_close_sync(g_conn, NULL, &err)) {
- if (err) {
- ERR("Fail to close the dbus connection: %s", err->message);
- g_error_free(err);
- }
- }
-
- g_object_unref(g_conn);
- g_conn = NULL;
- DBG("-");
-}
-
-static GDBusConnection *__bt_gatt_get_gdbus_connection(void)
-{
- GDBusConnection *local_system_gconn = NULL;
- char *address;
- GError *err = NULL;
-
- if (g_conn == NULL) {
- address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
- if (address == NULL) {
- if (err) {
- ERR("Failed to get bus address: %s", err->message);
- g_clear_error(&err);
- }
- return NULL;
- }
-
- g_conn = g_dbus_connection_new_for_address_sync(address,
- G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
- G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
- NULL, /* GDBusAuthObserver */
- NULL,
- &err);
- if (!g_conn) {
- if (err) {
- ERR("Unable to connect to dbus: %s", err->message);
- g_clear_error(&err);
- }
- return NULL;
- }
- } else if (g_dbus_connection_is_closed(g_conn)) {
- address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
- if (address == NULL) {
- if (err) {
- ERR("Failed to get bus address: %s", err->message);
- g_clear_error(&err);
- }
- return NULL;
- }
-
- local_system_gconn = g_dbus_connection_new_for_address_sync(address,
- G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
- G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
- NULL, /* GDBusAuthObserver */
- NULL,
- &err);
-
- if (!local_system_gconn) {
- ERR("Unable to connect to dbus: %s", err->message);
- g_clear_error(&err);
- }
-
- g_conn = local_system_gconn;
- }
-
- return g_conn;
-}
-
static char* __bt_hal_convert_uuid_to_string(bt_uuid_t *srvc_id)
{
char uuid_buf[5];
return strdup(uuid);
}
-int __bt_hal_add_service_to_dbus(char *app_path, int slot, btgatt_srvc_id_t *srvc_id)
+static int __bt_hal_add_service_to_dbus(char *app_path, int slot, btgatt_srvc_id_t *srvc_id)
{
gboolean ret;
/* For GATT service specific */
if (gatt_server_apps == NULL) {
INFO("All GATT servers are removed, clean all DBUS resources");
if (owner_id) {
- /* unregister the exported interface for object manager
- g_conn and manager_id are common for all GATT servers */
- g_dbus_connection_unregister_object(g_conn,
- manager_id);
+ /* unregister the exported interface for object manager */
+ g_dbus_connection_unregister_object(g_conn, manager_id);
manager_id = 0;
g_bus_unown_name(owner_id);
owner_id = 0;
g_object_unref(manager_gproxy);
manager_gproxy = NULL;
-
- /* Close the GDBUS connection */
- __bt_gatt_close_gdbus_connection();
}
}
INFO("-");
}
-int __bt_hal_gatt_init(void)
+static int __bt_hal_gatt_init(void)
{
- GDBusConnection *conn = NULL;
DBG("+");
+
/* Only once for ALL GATT Servers */
if (owner_id == 0) {
- owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
- BT_GATT_SERVICE_NAME,
- G_BUS_NAME_OWNER_FLAGS_NONE,
- NULL, NULL, NULL, NULL, NULL);
- }
- INFO("Owner ID [%d]", owner_id);
+ GError *err = NULL;
+ gchar *name = NULL;
- /* Only once for ALL GATT Servers conn = g_conn(global)*/
- conn = __bt_gatt_get_gdbus_connection();
- if (!conn) {
- ERR("Unable to get connection");
- return BT_STATUS_FAIL;
+ g_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (!g_conn) {
+ if (err) {
+ ERR("Unable to connect to gdbus: %s", err->message);
+ g_clear_error(&err);
+ }
+ return BT_STATUS_FAIL;
+ }
+
+ name = g_strdup_printf("%s.p%d", BT_GATT_SERVICE_NAME, getpid());
+ INFO("well-known name: %s", name);
+
+ owner_id = g_bus_own_name_on_connection(g_conn, name,
+ G_BUS_NAME_OWNER_FLAGS_NONE,
+ NULL, NULL, NULL, NULL);
}
+ INFO("Owner ID [%d]", owner_id);
/* Only once for ALL GATT Servers */
if (manager_node_info == NULL) {
return BT_STATUS_SUCCESS;
}
-void _bt_hal_is_gatt_server_initialzed(int slot, char **app_path)
+static void _bt_hal_is_gatt_server_initialzed(int slot, char **app_path)
{
GSList *l;
*app_path = NULL;
}
-void _bt_hal_update_gatt_server_path(int slot, char *app_path)
+static void _bt_hal_update_gatt_server_path(int slot, char *app_path)
{
if (app_path == NULL)
return;
char *app_path = NULL;
GError *error = NULL;
int *app_id = NULL;
- guint manager_id;
int result = BT_STATUS_SUCCESS;
g_error_free(error);
goto failed;
}
+ INFO("manager_id [%d]", manager_id);
/* For current GATT Server, app_path is created, save it in Table */
_bt_hal_update_gatt_server_path(server_if, app_path);
g_variant_builder_add(outer_builder, "{sv}", "Notifying",
g_variant_new("b", notify));
- _bt_hal_convert_addr_type_to_string(addr, (unsigned char *)conn_info->addr);
+ memcpy(addr, conn_info->addr, BT_HAL_ADDRESS_STRING_SIZE);
+ DBG("Send Indication to Unicast addr [%s]", addr);
g_variant_builder_add(outer_builder, "{sv}", "Unicast",
g_variant_new("s", addr));
/* DEBUG */
for (i = 0; i < response->attr_value.len; i++)
- DBG("Resonse [%d] = [0x%x]", response->attr_value.value[i]);
+ DBG("Resonse [%d] = [0x%x]", i, response->attr_value.value[i]);
if (req_info->request_type == BT_HAL_GATT_REQUEST_TYPE_READ) {
GVariantBuilder *inner_builder = NULL;
static bt_status_t gatt_server_listen(int server_if, bool start)
{
CHECK_BTGATT_INIT();
+
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ DBG("server_if: [%d]", server_if);
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ DBG("gatt server is not registered");
+ return BT_STATUS_FAIL;
+ }
+
+ DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+ if (server_register_info->adv_slot_id < 0 ) {
+ DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+ return BT_STATUS_FAIL;
+ }
+
/* Send Data to LE Module */
- return _bt_hal_enable_advertising(server_if, start, FALSE);
+ return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, start, FALSE);
}
static bt_status_t gatt_server_set_adv_data(int server_if, bool set_scan_rsp, bool include_name,
return BT_STATUS_SUCCESS;
}
+static int bt_hal_gatts_allocate_adv_slot(struct hal_gatts_server_register_info_t *server_register_info)
+{
+ int adv_slot_id = -1;
+
+ /* allocate adv slot for gatt server if not assigned */
+ if (server_register_info->adv_slot_id < 0 ) {
+ adv_slot_id = _bt_hal_get_available_adv_slot_id(&server_register_info->app_uuid, FALSE);
+ if (adv_slot_id < 0) {
+ ERR("failed to get the adv_slot");
+ return -1;
+ }
+
+ server_register_info->adv_slot_id = adv_slot_id;
+ }
+
+ DBG("gatt server:[%d] Assigned adv_slot [%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+ return 0;
+}
+
+int bt_hal_gatts_allocate_adv_slot_by_server_if(int server_if)
+{
+ CHECK_BTGATT_INIT();
+
+ int ret = -1;
+
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ DBG("server_if: [%d]", server_if);
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ DBG("gatt server is not registered");
+ return -1;
+ }
+
+ DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+ if (server_register_info->adv_slot_id < 0 ) {
+ DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+
+ ret = bt_hal_gatts_allocate_adv_slot(server_register_info);
+ if (ret < 0) {
+ DBG("failed to get adv_slot");
+ return -1;
+ }
+ }
+
+ return server_register_info->adv_slot_id;
+}
+
+void bt_hal_gatts_release_adv_slot(int server_if)
+{
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ ERR("failed to get server_register_info");
+ return;
+ }
+
+ if (server_register_info->adv_slot_id < 0) {
+ ERR("adv_slot is not allocated");
+ return;
+ }
+
+ if(_bt_hal_is_advertising_in_slot(server_register_info->adv_slot_id) == FALSE) {
+ DBG("advertising is disabled");
+ _bt_hal_free_server_slot(server_register_info->adv_slot_id);
+ server_register_info->adv_slot_id = -1;
+ }
+}
+
+int bt_hal_gatts_get_adv_slot_id(int server_if)
+{
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ DBG("failed to get server_register_info");
+ return -1;
+ }
+
+ return server_register_info->adv_slot_id;
+}
+
+int bt_hal_gatts_get_server_if(int slot_id)
+{
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ server_register_info = bt_hal_gatts_find_server_register_info_by_slot_id(slot_id);
+ if (server_register_info == NULL) {
+ DBG("failed to get server_register_info");
+ return -1;
+ }
+
+ return server_register_info->server_if;
+}
+
static bt_status_t gatt_server_multi_adv_enable(int server_if)
{
CHECK_BTGATT_INIT();
+
+ int ret = -1;
+
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ DBG("server_if: [%d]", server_if);
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ ERR("gatt server is not registered");
+ return BT_STATUS_FAIL;
+ }
+
+ DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+ if (server_register_info->adv_slot_id < 0 ) {
+ DBG("adv_slot is not assigned to server:[%d]", server_if);
+
+ ret = bt_hal_gatts_allocate_adv_slot(server_register_info);
+ if (ret < 0) {
+ ERR("failed to get adv_slot");
+ return BT_STATUS_FAIL;
+ }
+ }
+
/* Send Enable Advertising request to LE Module */
- return _bt_hal_enable_advertising(server_if, TRUE, TRUE);
+ return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, TRUE, TRUE);
}
static bt_status_t gatt_server_multi_adv_update(int server_if, int min_interval, int max_interval, int adv_type,
chnl_map, tx_power, timeout_s);
}
-static bt_status_t gatt_server_multi_adv_set_inst_data(btgatt_adv_param_setup_t adv_param_setup)
+static bt_status_t gatt_server_set_filter_policy(int filter_policy)
{
CHECK_BTGATT_INIT();
DBG("+");
+ /* Send the Filter policy parameter to LE Module */
+ _bt_hal_set_filter_policy_param(filter_policy);
+ return BT_STATUS_SUCCESS;
+}
+
+static bt_status_t gatt_server_multi_adv_set_inst_data(btgatt_adv_param_setup_t adv_param_setup)
+{
+ CHECK_BTGATT_INIT();
+
/* Send Data to LE Module */
return _bt_hal_set_advertising_data(adv_param_setup);
}
static bt_status_t gatt_server_multi_adv_disable(int server_if)
{
CHECK_BTGATT_INIT();
+
+ struct hal_gatts_server_register_info_t *server_register_info = NULL;
+
+ DBG("server_if: [%d]", server_if);
+
+ server_register_info = bt_hal_gatts_find_server_register_info(server_if);
+ if (server_register_info == NULL) {
+ DBG("gatt server is not registered");
+ return BT_STATUS_FAIL;
+ }
+
+ DBG("gatt server:[%d], adv_slot:[%d]", server_register_info->server_if, server_register_info->adv_slot_id);
+
+ if (server_register_info->adv_slot_id < 0 ) {
+ DBG("adv_slot is not assigned to server:[%d] \n", server_if);
+ return BT_STATUS_FAIL;
+ }
+
/* Send Data to LE Module */
- return _bt_hal_enable_advertising(server_if, FALSE, TRUE);
+ return _bt_hal_enable_advertising(server_if, server_register_info->adv_slot_id, FALSE, TRUE);
}
static bt_status_t gatt_server_get_mtu_size(int conn_id, int *mtu_size)
.set_adv_data = gatt_server_set_adv_data,
.multi_adv_enable = gatt_server_multi_adv_enable,
.multi_adv_update = gatt_server_multi_adv_update,
+ .set_filter_policy = gatt_server_set_filter_policy,
.multi_adv_set_inst_data = gatt_server_multi_adv_set_inst_data,
.multi_adv_disable = gatt_server_multi_adv_disable,
.get_att_mtu = gatt_server_get_mtu_size,