This patch implements the Mesh node role for device.
Join API create a fresh node and set callbacks for join complete
and message execution callbacks.
Cancel API destroy the outgoing request initiated by Join API
and destroy the node from the application
Change-Id: Ic7127b90849223626c94351c63a2e86e092065f6
Signed-off-by: anuj.bhumiya <anuj.bhumiya@samsung.com>
* @since_tizen 6.5
* @privlevel platform
*/
-int bt_mesh_network_join(bt_mesh_node_h node_handle,
- bt_mesh_join_complete_cb cb, void *user_data);
+int bt_mesh_node_network_join(bt_mesh_node_h node_handle,
+ bt_mesh_join_complete_cb callback, void *user_data);
/**
* @internal
*
* @param: in: node_handle, Local Mesh node
*
- * @see bt_mesh_network_join
+ * @see bt_mesh_node_network_join
* @since_tizen 6.5
* @privlevel platform
*/
-int bt_mesh_cancel_join(bt_mesh_node_h node_handle);
+int bt_mesh_node_cancel_join(bt_mesh_node_h node_handle);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MESH_MODULE
+ * @brief Registers a callback that will be invoked when message is
+ * received from any node either remote node or from provisioner node
+ *
+ * @pre Either bt_mesh_network_provision_device() in case of Provisioner role
+ * or bt_mesh_node_network_join() in case of Node role must be called
+ *
+ * @param[in] callback, callback function which is set, for receiving any message.
+ *
+ * @see bt_network_provision_device()
+ * @see bt_mesh_node_network_join()
+ * @since_tizen 6.5
+ * @privlevel platform
+ */
+int bt_mesh_node_model_set_msg_cb(bt_mesh_node_h node_handle,
+ bt_mesh_model_msg_cb callback,
+ void *user_data);
/**
* @internal
BT_EVENT_MESH_NODE_MODEL_GROUP_SUB, /**< Mesh - Model Virtual Subscription - Add/Delete/overwrite/DeleteAll */
BT_EVENT_MESH_NODE_MODEL_GROUP_VIR_SUB, /**< Mesh - Model Virtual Subscription - Add/Delete/overwrite/DeleteAll */
BT_EVENT_MESH_NODE_MODEL_PUBLICATION, /**< Mesh - Model Publication Status event index */
+ BT_EVENT_MESH_JOIN_NETWORK, /**< Mesh - Join Complete callback */
BT_EVENT_MAX
} bt_event_e;
const char *dev_uuid, void *user_data);
typedef void (*bt_mesh_join_complete_cb)
- (int result, bt_mesh_node_h node_handle,
- char *token, void *user_data);
+ (int result, bt_mesh_node_h node,
+ void *user_data);
typedef void (*bt_mesh_authentication_request_cb)
(int result, bt_mesh_authentication_type_e auth_type,
{ BLUETOOTH_EVENT_MESH_MODEL_SUBSCRIPTION_CONFGURED, BT_EVENT_MESH_NODE_MODEL_GROUP_SUB },
{ BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED, BT_EVENT_MESH_NODE_MODEL_GROUP_VIR_SUB },
{ BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS, BT_EVENT_MESH_NODE_MODEL_PUBLICATION },
+ { BLUETOOTH_EVENT_MESH_JOIN_COMPLETED, BT_EVENT_MESH_JOIN_NETWORK },
{ 0, -1 }
};
case BLUETOOTH_EVENT_MESH_MODEL_VIRTUAL_SUBSCRIPTION_CONFGURED:
case BLUETOOTH_EVENT_MESH_MODEL_PUBLICATION_STATUS:
case BLUETOOTH_EVENT_MESH_MODEL_MSG_EXECUTED:
+ case BLUETOOTH_EVENT_MESH_JOIN_COMPLETED:
return true;
default:
break;
(bt_mesh_appkey_h) appkey_s, msg,
bt_event_slot_container[event_index].user_data);
break;
+ } case BLUETOOTH_EVENT_MESH_JOIN_COMPLETED: {
+ BT_INFO("BLUETOOTH_EVENT_MESH_JOIN_FINISHED");
+ bluetooth_mesh_node_t *node = NULL;
+ bt_mesh_node_s *info = NULL;
+ node = (bluetooth_mesh_node_t *)(param->param_data);
+
+ info = (bt_mesh_node_s*)node;
+ if (!info) {
+ BT_INFO("Node Handel not received");
+ break;
+ }
+ ((bt_mesh_join_complete_cb)
+ bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), (bt_mesh_node_h) info,
+ bt_event_slot_container[event_index].user_data);
+ break;
}
default:
BT_INFO("Unknown function");
return error_code;
}
+int bt_mesh_node_network_join(bt_mesh_node_h node_handle,
+ bt_mesh_join_complete_cb callback,
+ void *user_data)
+{
+ FUNC_ENTRY;
+ int error_code = BT_ERROR_NONE;
+ GSList *l1, *l2;
+ int i, j;
+ int offset = 0;
+ int num_models = 0;
+
+ bluetooth_mesh_node_t param_node;
+ bluetooth_mesh_model_t **param_model = NULL;
+
+ BT_CHECK_MESH_SUPPORT();
+ BT_CHECK_MESH_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(node_handle);
+ BT_CHECK_INPUT_PARAMETER(callback);
+
+ bt_mesh_node_s *node = (bt_mesh_node_s*)node_handle;
+ BT_MESH_VALIDATE_HANDLE(node, node_list);
+
+ BT_CHECK_MESH_IS_ATTACHED(node);
+
+ /* Node should contain at-least one element */
+ if (!g_slist_length(node->elements)) {
+ BT_INFO("Mesh: No element present in Node: NOT ALLOWED!!");
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ /* Element in Node should contain at-least one Model */
+ for (l1 = node->elements; l1 != NULL; l1 = l1->next) {
+ bt_mesh_element_s *el = l1->data;
+ int models = 0;
+ models = g_slist_length(el->models);
+ BT_INFO("Mesh: Num models element [%u] has is [%d]", el->index, models);
+ if (!models) {
+ BT_INFO("Mesh: No Model present in element: NOT ALLOWED!!");
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+ /* If Primary element does not contain CFG SRV model, create and append */
+ if (el->index == 0x0000) {
+ uint32_t mod_id = 0xFFFF0000; /* CFG SRV */
+
+ if (!g_slist_find_custom(el->models, GUINT_TO_POINTER(mod_id),
+ (GCompareFunc)__compare_model_id)) {
+ bt_mesh_model_s *model_s;
+ BT_ERR("Mesh: Primary element does not contain CFG SRV Model:Add it!");
+ model_s = g_malloc0(sizeof(bt_mesh_model_s));
+
+ model_s->is_local = true;
+ model_s->parent = el;
+ model_s->id = mod_id;
+ model_list = g_slist_append(model_list, model_s);
+ el->models = g_slist_append(el->models, model_s);
+ num_models++;
+ } else
+ BT_INFO("Mesh: CFG SRV model is already added in primary element");
+ }
+ num_models += models;
+ }
+
+ memset(¶m_node, 0x00, sizeof(bluetooth_mesh_node_t));
+ param_node.vendor_info.companyid = node->features.cid;
+ param_node.vendor_info.vendorid = node->features.pid;
+ param_node.vendor_info.versionid = node->features.vid;
+ param_node.vendor_info.crpl = node->features.crpl;
+
+ if (node->features.features & BT_MESH_FEATURE_RELAY)
+ param_node.vendor_info.relay = 1;
+ if (node->features.features & BT_MESH_FEATURE_PROXY)
+ param_node.vendor_info.proxy = 1;
+ if (node->features.features & BT_MESH_FEATURE_FRIEND)
+ param_node.vendor_info.frnd = 1;
+ if (node->features.features & BT_MESH_FEATURE_LOWPOWER)
+ param_node.vendor_info.lpn = 1;
+
+ param_node.num_elements = g_slist_length(node->elements);
+ param_node.primary_unicast = 0x0001;
+ _bt_get_random_bytes(param_node.uuid, 16);
+
+ BT_INFO("Mesh: Total Models [%d]", num_models);
+ param_model = (bluetooth_mesh_model_t**)g_malloc0(num_models * sizeof(bluetooth_mesh_model_t*));
+
+ for (l1 = node->elements, i = 0; l1 != NULL; l1 = l1->next, i++) {
+ bt_mesh_element_s *e = l1->data;
+ for (l2 = e->models, j = 0; l2 != NULL; l2 = l2->next, j++) {
+ bt_mesh_model_s *m = l2->data;
+ param_model[j+offset] = g_malloc0(sizeof(bluetooth_mesh_model_t));
+ param_model[j+offset]->elem_index = i;
+ param_model[j+offset]->model_id = m->id;
+ }
+ offset += g_slist_length(e->models);
+ }
+
+ BT_INFO("Mesh: Send Join Network Request to FRWK");
+ error_code = _bt_get_error_code(bluetooth_mesh_network_join(¶m_node,
+ num_models, param_model));
+ if (error_code != BT_ERROR_NONE) {
+ BT_INFO("Mesh: Remote Node could not be created!!");
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+
+ /* Cleanup */
+ for (int i = 0; i < num_models; i++)
+ g_free(param_model[i]);
+
+ g_free(param_model);
+ return error_code;
+ }
+
+ BT_INFO("Mesh: Remote Node created successfully");
+
+ /* Fill Node Data */
+ node->is_attached = false;
+ node->is_provisioner = false;
+ __bt_mesh_util_convert_hex_to_string((uint8_t *)param_node.uuid,
+ 16, node->uuid, sizeof(node->uuid));
+
+ BT_INFO("Mesh: Node UUID [%s]", node->uuid);
+ /* Clean up memory */
+ for (int i = 0; i < num_models; i++)
+ g_free(param_model[i]);
+ g_free(param_model);
+ _bt_set_cb(BT_EVENT_MESH_JOIN_NETWORK, callback, user_data);
+ FUNC_EXIT;
+ return BT_ERROR_NONE;
+}
+
+int bt_mesh_node_cancel_join(bt_mesh_node_h node_handle)
+{
+ FUNC_ENTRY;
+ int error_code = BT_ERROR_NONE;
+ bluetooth_mesh_node_info_t node;
+
+ BT_CHECK_MESH_SUPPORT();
+ BT_CHECK_MESH_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(node_handle);
+
+ bt_mesh_node_s *node_s = (bt_mesh_node_s*)node_handle;
+ BT_MESH_VALIDATE_HANDLE(node_s, node_list);
+ BT_CHECK_MESH_IS_ATTACHED(node_s);
+ memset(&node, 0x00, sizeof(bluetooth_mesh_node_info_t));
+
+ BT_INFO("Mesh: Node UUID [%s]", node_s->uuid);
+ BT_INFO("Mesh: Send Cancel ongoing Request to FRWK");
+ g_strlcpy(node.net_uuid, node_s->uuid, 33);
+ error_code = _bt_get_error_code(bluetooth_mesh_cancel_join(&node));
+ if (error_code != BT_ERROR_NONE) {
+ BT_INFO("Mesh: Failed to cancel Join!!");
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ FUNC_EXIT;
+ return error_code;
+ }
+
+ BT_INFO("Mesh: Ongoing Join request cancelled successfully");
+ node_list = g_slist_remove(node_list, node_s);
+ g_slist_free_full(node_s->elements, __bt_mesh_free_elements);
+ g_free(node_s);
+
+ FUNC_EXIT;
+ return error_code;
+}
+
+int bt_mesh_node_model_set_msg_cb(bt_mesh_node_h node_handle,
+ bt_mesh_model_msg_cb callback, void *user_data)
+{
+ FUNC_ENTRY;
+ BT_CHECK_MESH_SUPPORT();
+ BT_CHECK_MESH_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ BT_CHECK_INPUT_PARAMETER(node_handle);
+
+ _bt_set_cb(BT_EVENT_MESH_NODE_MODEL_EXECUTE_MSG_COMPLETED, callback, user_data);
+ FUNC_EXIT;
+ return BT_ERROR_NONE;
+}
+
int bt_mesh_network_get_name(bt_mesh_network_h network, char **network_name)
{
bt_mesh_network_s *network_s;
{NULL , 0X0000},
};
+tc_table_t tc_join_scenario[] = {
+ {"Back"
+ , BT_MESH_UNIT_TEST_FUNCTION_BACK},
+ {"bt_mesh_scenario_network_join"
+ , BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN},
+ {"Cancel"
+ , BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL},
+ {"Set Message execuation callback"
+ , BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB},
+ {"select this menu to set parameters and then select the function again"
+ , BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS},
+ {NULL , 0X0000},
+};
+
tc_table_t tc_main[] = {
{"bt_mesh_initialize"
, BT_MESH_UNIT_TEST_FUNCTION_INITIALIZE},
, BT_MESH_UNIT_TEST_TABLE_CONTROL},
{"Scenerio"
, BT_MESH_UNIT_TEST_TABLE_SCENARIO},
+ {"Join_Scenerio"
+ , BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO},
{"Finish"
, BT_MESH_UNIT_TEST_TABLE_FINISH},
{NULL , 0x0000},
case BT_MESH_UNIT_TEST_TABLE_SCENARIO:
tc_table = tc_scenario;
break;
+ case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+ tc_table = tc_join_scenario;
+ break;
default:
tc_table = tc_main;
break;
print_network_handle(network);
}
+void __bt_mesh_join_complete_cb(int result, bt_mesh_node_h node,
+ void *user_data)
+{
+ TC_PRT("result: %s", __bt_get_error_message(result));
+ TC_PRT("network_handle = [%p]", (void*)node);
+}
+
bool __bt_mesh_appkey_info_cb(int result, bt_mesh_network_h network, int total,
bt_mesh_netkey_h netkey, bt_mesh_appkey_h appkey, uint16_t appkey_index, void *user_data)
{
}
break;
}
+ case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+ {
+ switch (test_id) {
+ case BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL:
+ param_count = 1;
+ TC_PRT("Input param(%d) (node_handle)\n", param_index + 1);
+ break;
+ case BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB:
+ param_count = 1;
+ TC_PRT("Input param(%d) (node_handle)\n", param_index + 1);
+ break;
+ default:
+ TC_PRT("There is no parameter to set\n");
+ break;
+ }
+ break;
+ }
case BT_MESH_UNIT_TEST_TABLE_CONFIGURATION: {
switch (test_id) {
case BT_MESH_UNIT_TEST_FUNCTION_MESH_NETWORK_DISCOVER_NODE:
if (ret != BT_ERROR_NONE)
TC_PRT("return %s\n", __bt_get_error_message(ret));
- break;
+ break;
}
case BT_MESH_UNIT_TEST_SCENARIO_UNPROVISIONED_SCAN: {
unprov_dev_list = NULL;
__bt_free_test_param(&g_test_param);
break;
}
+ case BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO:
+ {
+ switch (test_id) {
+ case BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN: {
+ bt_mesh_element_h element_sh;
+ bt_mesh_model_h model_sh1, model_sh3, model_sh4;
+ bt_mesh_model_id_s mod_id1, mod_id3, mod_id4;
+ bt_mesh_node_features_s features;
+ features.features = BT_MESH_FEATURE_RELAY;
+ features.features |= BT_MESH_FEATURE_LOWPOWER;
+
+ // create node
+ ret = bt_mesh_node_create(&features, &local_node);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_node_create return %s\n", __bt_get_error_message(ret));
+
+ // create element
+ ret = bt_mesh_node_create_element(local_node, &element_sh);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_node_create_element return %s\n", __bt_get_error_message(ret));
+
+ // create models
+ // Add configuration server
+ memset(&mod_id1, 0x00, sizeof(bt_mesh_model_id_s));
+ mod_id1.model_id = BT_MESH_MODEL_ID_CFG_SRV;
+ mod_id1.company_id = 0xFFFF;
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("The model_id is [0x%2.2X]\n", mod_id1.model_id);
+ ret = bt_mesh_element_create_model(element_sh, &mod_id1, &model_sh1);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+ // Add Generic on-off client and server
+ memset(&mod_id3, 0x00, sizeof(bt_mesh_model_id_s));
+ mod_id3.model_id = BT_MESH_MODEL_ID_GEN_ONOFF_SRV;
+ mod_id3.company_id = 0xFFFF;
+ ret = bt_mesh_element_create_model(element_sh, &mod_id3, &model_sh3);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+ memset(&mod_id4, 0x00, sizeof(bt_mesh_model_id_s));
+ mod_id4.model_id = BT_MESH_MODEL_ID_GEN_ONOFF_CLIENT;
+ mod_id4.company_id = 0xFFFF;
+ ret = bt_mesh_element_create_model(element_sh, &mod_id4, &model_sh4);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_element_create_model return %s\n", __bt_get_error_message(ret));
+
+ // join network call
+ ret = bt_mesh_node_network_join(local_node, __bt_mesh_join_complete_cb, NULL);
+ if (ret != BT_ERROR_NONE)
+ TC_PRT("bt_mesh_node_network_join return %s", __bt_get_error_message(ret));
+ else {
+ TC_PRT("Mesh Node created!!");
+ print_node_handle(local_node);
+ }
+ break;
+ }
+ case BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL:{
+ bt_mesh_node_h node_h;
+ if (g_test_param.param_count != 1) {
+ TC_PRT("Enter parameters first!");
+ break;
+ }
+ node_h = GUINT_TO_POINTER(strtoul(g_test_param.params[0], NULL, 16));
+ ret = bt_mesh_node_cancel_join(node_h);
+ TC_PRT("return %s\n", __bt_get_error_message(ret));
+ break;
+ }
+ case BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB: {
+ bt_mesh_node_h node_h;
+ if (g_test_param.param_count != 1) {
+ TC_PRT("Enter parameters first!");
+ break;
+ }
+ node_h = GUINT_TO_POINTER(strtoul(g_test_param.params[0], NULL, 16));
+ ret = bt_mesh_node_model_set_msg_cb(node_h, __bt_mesh_model_msg_cb, NULL);
+ TC_PRT("returns %s\n", __bt_get_error_message(ret));
+ break;
+ }
+ case BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS: {
+ need_to_set_params = true;
+ TC_PRT("Select the function again");
+ break;
+ }
+ default:
+ break;
+ }
+ __bt_free_test_param(&g_test_param);
+ break;
+ }
default:
break;
}
return 0;
}
-
static gboolean key_event_cb(GIOChannel *chan,
GIOCondition cond,
gpointer data)
if (test_id == 0)
current_tc_table = BT_MESH_UNIT_TEST_TABLE_MAIN;
else if (test_id >= BT_MESH_UNIT_TEST_TABLE_NETWORK
- && test_id <= BT_MESH_UNIT_TEST_TABLE_SCENARIO) {
+ && test_id <= BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO) {
current_tc_table = test_id;
} else if (test_id > BT_MESH_UNIT_TEST_TABLE_CONTROL
&& test_id < BT_MESH_UNIT_TEST_TABLE_FINISH) {
BT_MESH_UNIT_TEST_TABLE_CONFIGURATION,
BT_MESH_UNIT_TEST_TABLE_CONTROL,
BT_MESH_UNIT_TEST_TABLE_SCENARIO,
+ BT_MESH_UNIT_TEST_TABLE_JOIN_SCENARIO,
BT_MESH_UNIT_TEST_TABLE_FINISH = 0XFF,
} bt_mesh_unit_test_table_e;
BT_MESH_UNIT_TEST_SCENARIO_MODEL_GENERIC_ONOFF_SET_OFF,
BT_MESH_UNIT_TEST_SCENARIO_GROUP_GENERIC_ONOFF_SET_ON,
BT_MESH_UNIT_TEST_SCENARIO_GROUP_GENERIC_ONOFF_SET_OFF,
+ BT_MESH_UNIT_TEST_SCENARIO_NETWORK_JOIN =1,
+ BT_MESH_UNIT_TEST_SCENARIO_JOIN_CANCEL,
+ BT_MESH_UNIT_TEST_SCENARIO_SET_MSG_CB,
BT_MESH_UNIT_TEST_FUNCTION_ACTIVATE_FLAG_TO_SET_PARAMETERS = 0XFF,
} bt_mesh_unit_test_function_e;
projects / platform / core / api / bluetooth.git / commitdiff