Fix Jira 834 Unexpected increase in compiled sketch image size

1. Reconstruct the initial process to avoid call BLE API

Changed files
BLEDeviceManager.cpp - Change the init order
  ble_client.c - Add new call
  ble_service.h - Add new API declaration
  ble_service.c - Modify init logic
  ble_service_api.c - Delete unsed file
  nble_driver.c - Modify init logic

Author: sgbihu

libraries/CurieBLE/src/internal/BLEDeviceManager.cpp

@@ -130,17 +130,18 @@ bool BLEDeviceManager::begin(BLEDevice *device)
 {
     if (NULL == _local_ble)
     {
+        // TODO: Olny allow call one time
+        ble_client_init (bleConnectEventHandler, this,
+                         bleDisconnectEventHandler, this,
+                         bleParamUpdatedEventHandler, this);
+        
         _local_ble = device;
         bt_le_set_mac_address(_local_bda);
 
         // Set device name    
         setDeviceName();
         _state = BLE_PERIPH_STATE_READY;
         delay(4);
-        // TODO: Olny allow call one time
-        ble_client_init (bleConnectEventHandler, this,
-                         bleDisconnectEventHandler, this,
-                         bleParamUpdatedEventHandler, this);
         return true;
     }
     else

libraries/CurieBLE/src/internal/ble_client.c

@@ -42,6 +42,7 @@
 #include "infra/version.h"
 #include "curie_factory_data.h"
 #include "portable.h"
+#include "services/ble/ble_service.h"
 
 #include "uart.h"
 #include "ipc_uart_ns16550.h"
@@ -193,7 +194,9 @@ void ble_client_init(ble_client_connect_event_cb_t connect_cb, void* connect_par
                      ble_client_disconnect_event_cb_t disconnect_cb, void* disconnect_param,
                      ble_client_update_param_event_cb_t update_param_cb, void* update_param_param)
 {
-    //uint32_t delay_until;
+    // Enable the HW
+    ble_enable();
+    
     pr_info(LOG_MODULE_BLE, "%s", __FUNCTION__);
     ble_client_connect_event_cb = connect_cb;
     ble_client_connect_event_param = connect_param;

system/libarc32_arduino101/framework/include/services/ble/ble_service.h

@@ -217,20 +217,7 @@ struct ble_dbg_req_rsp {
 	uint32_t u1;
 };
 
-/** Enable/Disable BLE stack. To be called before any BLE service related call.
- *
- * @param p_service_conn client service connection (cfw service connection)
- * @param enable 1: enable BLE stack 0: disable BLE stack
- * @param p_config configuration parameters when enabling BLE. shall be null in case of BLE disable. @ref ble_enable_config
- * @param p_priv pointer to private structure returned in a response
- *
- * @return @ref OS_ERR_TYPE
- * @note Expected notification:
- *       - Message with @ref MSG_ID_BLE_ENABLE_RSP and type @ref ble_enable_rsp.
- */
-int ble_service_enable(cfw_service_conn_t * p_service_conn, uint8_t enable,
-			const struct ble_enable_config * p_config,
-			void *p_priv);
+void ble_enable();
 
 /** @endcond */
 /** @}*/

system/libarc32_arduino101/framework/src/services/ble_service/ble_service.c

@@ -68,175 +68,175 @@ static const struct bt_conn_auth_cb auth_callbacks;
 #endif
 
 static service_t ble_service = {
-	.service_id = BLE_SERVICE_ID,
-	.client_connected = ble_client_connected,
-	.client_disconnected = ble_client_disconnected,
+    .service_id = BLE_SERVICE_ID,
+    .client_connected = ble_client_connected,
+    .client_disconnected = ble_client_disconnected,
 };
 
 static void ble_is_not_enabled_rsp(struct cfw_message *msg, int status)
 {
-	struct ble_enable_rsp *resp =
-	    (struct ble_enable_rsp *)cfw_alloc_rsp_msg(msg,
-			    /* translate msg from req to rsp */
-						(CFW_MESSAGE_ID(msg) ^ MSG_ID_BLE_SERVICE_BASE)
-						| MSG_ID_BLE_SERVICE_RSP,
-						sizeof(*resp));
-	resp->status = status;
-	cfw_send_message(resp);
+    struct ble_enable_rsp *resp =
+        (struct ble_enable_rsp *)cfw_alloc_rsp_msg(msg,
+                /* translate msg from req to rsp */
+                        (CFW_MESSAGE_ID(msg) ^ MSG_ID_BLE_SERVICE_BASE)
+                        | MSG_ID_BLE_SERVICE_RSP,
+                        sizeof(*resp));
+    resp->status = status;
+    cfw_send_message(resp);
 }
 
 #ifdef CONFIG_TCMD_BLE_DEBUG
 static void handle_msg_id_ble_dbg(struct cfw_message *msg)
 {
-	struct nble_dbg_req params;
-	struct ble_dbg_req_rsp *resp = (void *)
-		cfw_alloc_rsp_msg(msg, MSG_ID_BLE_DBG_RSP, sizeof(*resp));
-	struct ble_dbg_req_rsp *req = (struct ble_dbg_req_rsp *) msg;
+    struct nble_dbg_req params;
+    struct ble_dbg_req_rsp *resp = (void *)
+        cfw_alloc_rsp_msg(msg, MSG_ID_BLE_DBG_RSP, sizeof(*resp));
+    struct ble_dbg_req_rsp *req = (struct ble_dbg_req_rsp *) msg;
 
-	params.u0 = req->u0;
-	params.u1 = req->u1;
+    params.u0 = req->u0;
+    params.u1 = req->u1;
     params.user_data = (void *)resp;
-	nble_dbg_req(&params);
+    nble_dbg_req(&params);
 }
 #endif /* CONFIG_TCMD_BLE_DEBUG */
 
 void on_nble_dbg_rsp(const struct nble_dbg_rsp *params)
 {
 #ifdef CONFIG_TCMD_BLE_DEBUG
-	struct ble_dbg_req_rsp *resp = params->user_data;
-	if (!resp)
-		return;
-	resp->u0 = params->u0;
-	resp->u1 = params->u1;
-	cfw_send_message(resp);
+    struct ble_dbg_req_rsp *resp = params->user_data;
+    if (!resp)
+        return;
+    resp->u0 = params->u0;
+    resp->u1 = params->u1;
+    cfw_send_message(resp);
 #endif /* CONFIG_TCMD_BLE_DEBUG */
 }
 
 
 static void handle_msg_id_ble_rpc_callin(struct message *msg, void *priv)
 {
-	struct ble_rpc_callin *rpc = container_of(msg, struct ble_rpc_callin, msg);
-	/* handle incoming message */
+    struct ble_rpc_callin *rpc = container_of(msg, struct ble_rpc_callin, msg);
+    /* handle incoming message */
     //pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
-	rpc_deserialize(rpc->p_data, rpc->len);
-	bfree(rpc->p_data);
-	message_free(msg);
+    rpc_deserialize(rpc->p_data, rpc->len);
+    bfree(rpc->p_data);
+    message_free(msg);
     //pr_debug(LOG_MODULE_BLE, "%s-%d", __FUNCTION__, __LINE__);
 }
 
 static void ble_set_bda_cb(int status, 
                            void *user_data, 
                            const bt_addr_le_t *bda)
 {
-	struct ble_enable_req *req = user_data;
+    struct ble_enable_req *req = user_data;
 
-	if (!req)
-		return;
+    if (!req)
+        return;
 
-	struct ble_enable_rsp *resp = (void *)cfw_alloc_rsp_msg(&req->header,
+    struct ble_enable_rsp *resp = (void *)cfw_alloc_rsp_msg(&req->header,
                                                             MSG_ID_BLE_ENABLE_RSP, 
                                                             sizeof(*resp));
-	resp->status = status;
-
-	if (status == 0) {
-		resp->enable = 1;
-
-		//nble_read_bda_req(resp);
-	} else {
-		/* error case */
-		resp->enable = 0;
-		cfw_send_message(resp);
-	}
-	bfree(req);
+    resp->status = status;
+
+    if (status == 0) {
+        resp->enable = 1;
+
+        //nble_read_bda_req(resp);
+    } else {
+        /* error case */
+        resp->enable = 0;
+        cfw_send_message(resp);
+    }
+    bfree(req);
 }
 
 static void handle_ble_enable(struct ble_enable_req *req,
                               struct _ble_service_cb *p_cb)
 {
-	pr_info(LOG_MODULE_BLE, "ble_enable: state %d", p_cb->ble_state);
+    pr_info(LOG_MODULE_BLE, "ble_enable: state %d", p_cb->ble_state);
 
-	p_cb->ble_state = BLE_ST_ENABLED;
+    p_cb->ble_state = BLE_ST_ENABLED;
 
-	if (req->bda_present) {
-		struct nble_set_bda_req params;
+    if (req->bda_present) {
+        struct nble_set_bda_req params;
 
-		params.cb = ble_set_bda_cb;
-		params.user_data = req;
-		params.bda = req->bda;
+        params.cb = ble_set_bda_cb;
+        params.user_data = req;
+        params.bda = req->bda;
 
-		nble_set_bda_req(&params);
-	} else {
-		ble_set_bda_cb(0, req, NULL);
-	}
+        nble_set_bda_req(&params);
+    } else {
+        ble_set_bda_cb(0, req, NULL);
+    }
 }
 
 static void handle_ble_disable(struct ble_enable_req *req, struct _ble_service_cb *p_cb)
 {
-	struct ble_enable_rsp *resp;
+    struct ble_enable_rsp *resp;
 
-	pr_debug(LOG_MODULE_BLE, "ble_disable");
-	p_cb->ble_state = BLE_ST_DISABLED;
+    pr_debug(LOG_MODULE_BLE, "ble_disable");
+    p_cb->ble_state = BLE_ST_DISABLED;
 
-	bt_le_adv_stop();
+    bt_le_adv_stop();
 
-	resp = (void *)cfw_alloc_rsp_msg(&req->header,
-				MSG_ID_BLE_ENABLE_RSP,
-				sizeof(*resp));
-	cfw_send_message(resp);  // Sid. KW warning ack.
+    resp = (void *)cfw_alloc_rsp_msg(&req->header,
+                MSG_ID_BLE_ENABLE_RSP,
+                sizeof(*resp));
+    cfw_send_message(resp);  // Sid. KW warning ack.
 
 }
 
 static void ble_service_message_handler(struct cfw_message *msg, void *param)
 {
-	bool free_msg = true;
-	struct _ble_service_cb *p_cb = param;
-	uint16_t msg_id = CFW_MESSAGE_ID(msg);
-
-	if (p_cb->ble_state < BLE_ST_ENABLED &&
-		msg_id != MSG_ID_BLE_ENABLE_REQ) {
-		ble_is_not_enabled_rsp(msg, -ENODEV);
-		goto out;
-	}
-
-	switch (msg_id) {
-	case MSG_ID_BLE_ENABLE_REQ: {
-		struct ble_enable_req *req =
-			container_of(msg, struct ble_enable_req, header);
-		if (p_cb->ble_state) {
-			if (req->enable) {
-				handle_ble_enable(req, p_cb);
-				free_msg = false;
-			} else
-				handle_ble_disable(req, p_cb);
-		} else {
-			pr_debug(LOG_MODULE_BLE, "ble_hdl_msg: core service not opened!");
-			/* core service is not yet up */
-			struct ble_enable_rsp *resp = (void *)cfw_alloc_rsp_msg(msg,
-				MSG_ID_BLE_ENABLE_RSP, sizeof(*resp));
-			resp->status = -EINPROGRESS;
-			resp->enable = 0;
-			cfw_send_message(resp);  // Sid. KW warning ack.
-		}
-	}
-		break;
+    bool free_msg = true;
+    struct _ble_service_cb *p_cb = param;
+    uint16_t msg_id = CFW_MESSAGE_ID(msg);
+
+    if (p_cb->ble_state < BLE_ST_ENABLED &&
+        msg_id != MSG_ID_BLE_ENABLE_REQ) {
+        ble_is_not_enabled_rsp(msg, -ENODEV);
+        goto out;
+    }
+
+    switch (msg_id) {
+    case MSG_ID_BLE_ENABLE_REQ: {
+        struct ble_enable_req *req =
+            container_of(msg, struct ble_enable_req, header);
+        if (p_cb->ble_state) {
+            if (req->enable) {
+                handle_ble_enable(req, p_cb);
+                free_msg = false;
+            } else
+                handle_ble_disable(req, p_cb);
+        } else {
+            pr_debug(LOG_MODULE_BLE, "ble_hdl_msg: core service not opened!");
+            /* core service is not yet up */
+            struct ble_enable_rsp *resp = (void *)cfw_alloc_rsp_msg(msg,
+                MSG_ID_BLE_ENABLE_RSP, sizeof(*resp));
+            resp->status = -EINPROGRESS;
+            resp->enable = 0;
+            cfw_send_message(resp);  // Sid. KW warning ack.
+        }
+    }
+        break;
 #ifdef CONFIG_TCMD_BLE_DEBUG
-	case MSG_ID_BLE_DBG_REQ:
-		handle_msg_id_ble_dbg(msg);
-		break;
+    case MSG_ID_BLE_DBG_REQ:
+        handle_msg_id_ble_dbg(msg);
+        break;
 #endif
-	default:
-		pr_warning(LOG_MODULE_BLE, "unsupported %d", msg_id);
-		break;
-	}
+    default:
+        pr_warning(LOG_MODULE_BLE, "unsupported %d", msg_id);
+        break;
+    }
 out:
-	if (free_msg)
-		cfw_msg_free(msg);
+    if (free_msg)
+        cfw_msg_free(msg);
 }
 
 static void ble_client_connected(conn_handle_t *instance)
 {
-	if (_ble_cb.ble_state == BLE_ST_NOT_READY)
-		pr_warning(LOG_MODULE_BLE, "BLE_CORE service is not registered");
+    if (_ble_cb.ble_state == BLE_ST_NOT_READY)
+        pr_warning(LOG_MODULE_BLE, "BLE_CORE service is not registered");
 }
 
 static void ble_client_disconnected(conn_handle_t *instance)
@@ -246,26 +246,30 @@ static void ble_client_disconnected(conn_handle_t *instance)
 void ble_bt_rdy(int err)
 {
     BT_SERVICE_ASSERT(err == 0);
-	_ble_cb.ble_state = BLE_ST_DISABLED;
+    _ble_cb.ble_state = BLE_ST_DISABLED;
     ble_inited = true;
 
-	/* register BLE service */
-	if (cfw_register_service(_ble_cb.queue, 
+    /* register BLE service */
+    if (cfw_register_service(_ble_cb.queue, 
                              &ble_service,
                              ble_service_message_handler, 
                              &_ble_cb) == -1) {
-		panic(0xb1eb1e);
-	}
+        panic(0xb1eb1e);
+    }
 }
 
 void ble_cfw_service_init(int service_id, T_QUEUE queue)
 {
-    uint32_t time_stamp_last = 0;
-	_ble_cb.queue = queue;
-	_ble_cb.ble_state = BLE_ST_NOT_READY;
+    _ble_cb.queue = queue;
+    _ble_cb.ble_state = BLE_ST_NOT_READY;
+}
 
+void ble_enable()
+{
+    uint32_t time_stamp_last = 0;
+    
 #ifdef CONFIG_IPC_UART_NS16550
-	nble_driver_configure(queue, handle_msg_id_ble_rpc_callin);
+    nble_driver_configure(_ble_cb.queue, handle_msg_id_ble_rpc_callin);
 #endif
 
     ble_inited = false;