modules: location: Use CONFIG_LOCATION_SERVICE_EXTERNAL

Enable CONFIG_LOCATION_SERVICE_EXTERNAL so that all location
requests are routed through the application instead of letting
the location library communicate directly with nRF Cloud library.
This is needed to be able to buffer locations while offline.

Test cases are updated and added to cover the new configuration.

Signed-off-by: Jan Tore Guggedal <jantore.guggedal@nordicsemi.no>

Author: jtguggedal

app/prj.conf

@@ -168,7 +168,8 @@ CONFIG_SMF_INITIAL_TRANSITION=y
 CONFIG_LOCATION=y
 CONFIG_LOCATION_DATA_DETAILS=y
 CONFIG_LOCATION_METHOD_GNSS=y
-CONFIG_LOCATION_SERVICE_NRF_CLOUD_GNSS_POS_SEND=y
+CONFIG_LOCATION_METHOD_CELLULAR=y
+CONFIG_LOCATION_SERVICE_EXTERNAL=y
 CONFIG_LOCATION_REQUEST_DEFAULT_GNSS_TIMEOUT=60000
 CONFIG_LOCATION_REQUEST_DEFAULT_CELLULAR_TIMEOUT=30000
 CONFIG_LOCATION_REQUEST_DEFAULT_TIMEOUT=120000

app/src/modules/cloud/Kconfig.cloud

@@ -82,7 +82,7 @@ config APP_CLOUD_BACKOFF_MAX_SECONDS
 
 config APP_CLOUD_THREAD_STACK_SIZE
 	int "Thread stack size"
-	default 3328
+	default 6144
 
 config APP_CLOUD_MESSAGE_QUEUE_SIZE
 	int "Message queue size"

app/src/modules/cloud/cloud.c

@@ -11,6 +11,7 @@
 #include <zephyr/task_wdt/task_wdt.h>
 #include <net/nrf_cloud.h>
 #include <net/nrf_cloud_coap.h>
+#include <net/nrf_cloud_rest.h>
 #include <nrf_cloud_coap_transport.h>
 #include <zephyr/net/coap.h>
 #include <app_version.h>
@@ -24,6 +25,7 @@
 #include "cloud.h"
 #include "app_common.h"
 #include "network.h"
+#include "location.h"
 
 #if defined(CONFIG_APP_POWER)
 #include "power.h"
@@ -48,14 +50,15 @@ ZBUS_MSG_SUBSCRIBER_DEFINE(cloud_subscriber);
 
 /* Define the channels that the module subscribes to, their associated message types
  * and the subscriber that will receive the messages on the channel.
- * ENVIRONMENTAL_CHAN and POWER_CHAN are optional and are only included if the
+ * ENVIRONMENTAL_CHAN, POWER_CHAN, and LOCATION_CHAN are optional and are only included if the
  * corresponding module is enabled.
  */
 #define CHANNEL_LIST(X)										\
 					 X(NETWORK_CHAN,	struct network_msg)		\
 					 X(CLOUD_CHAN,		struct cloud_msg)		\
 IF_ENABLED(CONFIG_APP_ENVIRONMENTAL,	(X(ENVIRONMENTAL_CHAN,	struct environmental_msg)))	\
-IF_ENABLED(CONFIG_APP_POWER,		(X(POWER_CHAN,		struct power_msg)))
+IF_ENABLED(CONFIG_APP_POWER,		(X(POWER_CHAN,		struct power_msg)))		\
+IF_ENABLED(CONFIG_APP_LOCATION,		(X(LOCATION_CHAN,	struct location_msg)))
 
 /* Calculate the maximum message size from the list of channels */
 #define MAX_MSG_SIZE			MAX_MSG_SIZE_FROM_LIST(CHANNEL_LIST)
@@ -443,6 +446,118 @@ static void state_connected_exit(void *obj)
 	}
 }
 
+#if defined(CONFIG_APP_LOCATION)
+/* Handle cloud location requests from the location module */
+static void handle_cloud_location_request(const struct location_data_cloud *request)
+{
+	int err;
+	struct location_data location = { 0 };
+	struct nrf_cloud_rest_location_request loc_req = {
+		.cell_info = (struct lte_lc_cells_info *)request->cell_data,
+		.wifi_info = (struct wifi_scan_info *)request->wifi_data,
+		.config = NULL
+	};
+	struct nrf_cloud_location_result result = { 0 };
+
+	LOG_DBG("Handling cloud location request");
+
+#if defined(CONFIG_LOCATION_METHOD_CELLULAR)
+	if (request->cell_data != NULL) {
+		LOG_DBG("Cellular data present: current cell ID: %d, neighbor cells: %d",
+			request->cell_data->current_cell.id,
+			request->cell_data->ncells_count);
+	}
+#endif
+
+#if defined(CONFIG_LOCATION_METHOD_WIFI)
+	if (request->wifi_data != NULL) {
+		LOG_DBG("Wi-Fi data present: %d APs", request->wifi_data->cnt);
+	}
+#endif
+
+	/* Send location request to nRF Cloud */
+	err = nrf_cloud_coap_location_get(&loc_req, &result);
+	if (err == -EACCES) {
+		LOG_WRN("Not connected to nRF Cloud, error: %d", err);
+		location_cloud_location_ext_result_set(LOCATION_EXT_RESULT_ERROR, NULL);
+		return;
+	} else if (err == -ETIMEDOUT) {
+		LOG_WRN("Location request timed out, error: %d", err);
+		location_cloud_location_ext_result_set(LOCATION_EXT_RESULT_ERROR, NULL);
+		return;
+	} else if (err == -ENETUNREACH) {
+		LOG_WRN("Network is unreachable, error: %d", err);
+		location_cloud_location_ext_result_set(LOCATION_EXT_RESULT_ERROR, NULL);
+		return;
+	} else if (err) {
+		LOG_ERR("nrf_cloud_coap_location_get failed, error: %d", err);
+		location_cloud_location_ext_result_set(LOCATION_EXT_RESULT_ERROR, NULL);
+		return;
+	}
+
+	LOG_INF("Location result: lat: %f, lon: %f, accuracy: %f",
+		result.lat, result.lon, (double)result.unc);
+
+	/* Convert result to location_data format */
+	location.latitude = result.lat;
+	location.longitude = result.lon;
+	location.accuracy = (double)result.unc;
+
+	/* Send successful result back to location library */
+	location_cloud_location_ext_result_set(LOCATION_EXT_RESULT_SUCCESS, &location);
+}
+
+#if defined(CONFIG_NRF_CLOUD_AGNSS)
+/* Handle A-GNSS data requests from the location module */
+static void handle_agnss_request(const struct nrf_modem_gnss_agnss_data_frame *request)
+{
+	int err;
+	static char agnss_buf[NRF_CLOUD_AGNSS_MAX_DATA_SIZE];
+	struct nrf_cloud_rest_agnss_request agnss_req = {
+		.type = NRF_CLOUD_REST_AGNSS_REQ_CUSTOM,
+		.agnss_req = (struct nrf_modem_gnss_agnss_data_frame *)request,
+		.net_info = NULL,
+		.filtered = false,
+		.mask_angle = 0
+	};
+	struct nrf_cloud_rest_agnss_result result = {
+		.buf = agnss_buf,
+		.buf_sz = sizeof(agnss_buf),
+		.agnss_sz = 0
+	};
+
+	LOG_DBG("Handling A-GNSS data request");
+
+	/* Send A-GNSS request to nRF Cloud */
+	err = nrf_cloud_coap_agnss_data_get(&agnss_req, &result);
+	if (err == -EACCES) {
+		LOG_WRN("Not connected to nRF Cloud, error: %d", err);
+		return;
+	} else if (err == -ETIMEDOUT) {
+		LOG_WRN("A-GNSS request timed out, error: %d", err);
+		return;
+	} else if (err == -ENETUNREACH) {
+		LOG_WRN("Network is unreachable, error: %d", err);
+		return;
+	} else if (err) {
+		LOG_ERR("nrf_cloud_coap_agnss_data_get failed, error: %d", err);
+		return;
+	}
+
+	LOG_DBG("A-GNSS data received, size: %d bytes", result.agnss_sz);
+
+	/* Process the A-GNSS data */
+	err = location_agnss_data_process(result.buf, result.agnss_sz);
+	if (err) {
+		LOG_ERR("Failed to process A-GNSS data, error: %d", err);
+		return;
+	}
+
+	LOG_DBG("A-GNSS data processed successfully");
+}
+#endif /* CONFIG_NRF_CLOUD_AGNSS */
+#endif /* CONFIG_APP_LOCATION */
+
 static void shadow_get(bool delta_only)
 {
 	int err;
@@ -659,6 +774,32 @@ static void state_connected_ready_run(void *obj)
 	}
 #endif /* CONFIG_APP_ENVIRONMENTAL */
 
+#if defined(CONFIG_APP_LOCATION)
+	if (state_object->chan == &LOCATION_CHAN) {
+		const struct location_msg *msg = MSG_TO_LOCATION_MSG_PTR(state_object->msg_buf);
+
+		switch (msg->type) {
+		case LOCATION_CLOUD_REQUEST:
+			LOG_DBG("Cloud location request received");
+			handle_cloud_location_request(&msg->cloud_request);
+			break;
+
+#if defined(CONFIG_NRF_CLOUD_AGNSS)
+		case LOCATION_AGNSS_REQUEST:
+			LOG_DBG("A-GNSS data request received");
+			handle_agnss_request(&msg->agnss_request);
+			break;
+#endif /* CONFIG_NRF_CLOUD_AGNSS */
+
+		default:
+			LOG_DBG("Unhandled location message type: %d", msg->type);
+			break;
+		}
+
+		return;
+	}
+#endif /* CONFIG_APP_LOCATION */
+
 	if (state_object->chan == &CLOUD_CHAN) {
 		const struct cloud_msg *msg = MSG_TO_CLOUD_MSG_PTR(state_object->msg_buf);
 

app/src/modules/location/location.c

@@ -13,7 +13,6 @@
 #include <modem/location.h>
 #include <nrf_modem_gnss.h>
 #include <date_time.h>
-#include <net/nrf_cloud.h>
 #include <modem/nrf_modem_lib.h>
 
 #include "app_common.h"
@@ -28,21 +27,21 @@ BUILD_ASSERT(CONFIG_APP_LOCATION_WATCHDOG_TIMEOUT_SECONDS >
 
 /* Define channels provided by this module */
 ZBUS_CHAN_DEFINE(LOCATION_CHAN,
-		 enum location_msg_type,
+		 struct location_msg,
 		 NULL,
 		 NULL,
 		 ZBUS_OBSERVERS_EMPTY,
 		 ZBUS_MSG_INIT(0)
 );
 
+#define MAX_MSG_SIZE sizeof(struct location_msg)
+
 /* Define listener for this module */
 ZBUS_MSG_SUBSCRIBER_DEFINE(location);
 
 /* Observe channels */
 ZBUS_CHAN_ADD_OBS(LOCATION_CHAN, location, 0);
 
-#define MAX_MSG_SIZE sizeof(enum location_msg_type)
-
 /* Forward declarations */
 static void location_event_handler(const struct location_event_data *event_data);
 
@@ -129,9 +128,43 @@ static void location_wdt_callback(int channel_id, void *user_data)
 static void status_send(enum location_msg_type status)
 {
 	int err;
-	enum location_msg_type location_status = status;
+	struct location_msg location_msg = {
+		.type = status
+	};
 
-	err = zbus_chan_pub(&LOCATION_CHAN, &location_status, K_SECONDS(1));
+	err = zbus_chan_pub(&LOCATION_CHAN, &location_msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+		return;
+	}
+}
+
+static void cloud_request_send(const struct location_data_cloud *cloud_request)
+{
+	int err;
+	struct location_msg location_msg = {
+		.type = LOCATION_CLOUD_REQUEST,
+		.cloud_request = *cloud_request
+	};
+
+	err = zbus_chan_pub(&LOCATION_CHAN, &location_msg, K_SECONDS(1));
+	if (err) {
+		LOG_ERR("zbus_chan_pub, error: %d", err);
+		SEND_FATAL_ERROR();
+		return;
+	}
+}
+
+static void agnss_request_send(const struct nrf_modem_gnss_agnss_data_frame *agnss_request)
+{
+	int err;
+	struct location_msg location_msg = {
+		.type = LOCATION_AGNSS_REQUEST,
+		.agnss_request = *agnss_request
+	};
+
+	err = zbus_chan_pub(&LOCATION_CHAN, &location_msg, K_SECONDS(1));
 	if (err) {
 		LOG_ERR("zbus_chan_pub, error: %d", err);
 		SEND_FATAL_ERROR();
@@ -152,9 +185,9 @@ void trigger_location_update(void)
 	}
 }
 
-void handle_location_chan(enum location_msg_type location_msg_type)
+void handle_location_chan(const struct location_msg *location_msg)
 {
-	if (location_msg_type == LOCATION_SEARCH_TRIGGER) {
+	if (location_msg->type == LOCATION_SEARCH_TRIGGER) {
 		LOG_DBG("Location search trigger received, getting location");
 		trigger_location_update();
 	}
@@ -184,14 +217,15 @@ static void state_running_run(void *obj)
 	struct location_state_object const *state_object = obj;
 
 	if (state_object->chan == &LOCATION_CHAN) {
-		handle_location_chan(MSG_TO_LOCATION_TYPE(state_object->msg_buf));
+		handle_location_chan(MSG_TO_LOCATION_MSG_PTR(state_object->msg_buf));
 	}
 }
 
 static void location_print_data_details(enum location_method method,
 					const struct location_data_details *details)
 {
 	LOG_DBG("Elapsed method time: %d ms", details->elapsed_time_method);
+
 #if defined(CONFIG_LOCATION_METHOD_GNSS)
 	if (method == LOCATION_METHOD_GNSS) {
 		LOG_DBG("Satellites tracked: %d", details->gnss.satellites_tracked);
@@ -200,12 +234,14 @@ static void location_print_data_details(enum location_method method,
 		LOG_DBG("GNSS execution time: %d ms", details->gnss.pvt_data.execution_time);
 	}
 #endif
+
 #if defined(CONFIG_LOCATION_METHOD_CELLULAR)
 	if (method == LOCATION_METHOD_CELLULAR || method == LOCATION_METHOD_WIFI_CELLULAR) {
 		LOG_DBG("Neighbor cells: %d", details->cellular.ncells_count);
 		LOG_DBG("GCI cells: %d", details->cellular.gci_cells_count);
 	}
 #endif
+
 #if defined(CONFIG_LOCATION_METHOD_WIFI)
 	if (method == LOCATION_METHOD_WIFI || method == LOCATION_METHOD_WIFI_CELLULAR) {
 		LOG_DBG("Wi-Fi APs: %d", details->wifi.ap_count);
@@ -282,6 +318,20 @@ static void location_event_handler(const struct location_event_data *event_data)
 
 		location_print_data_details(event_data->method, &event_data->fallback.details);
 		break;
+	case LOCATION_EVT_CLOUD_LOCATION_EXT_REQUEST:
+		LOG_DBG("Cloud location request received from location library");
+		cloud_request_send(&event_data->cloud_location_request);
+		break;
+#if defined(CONFIG_NRF_CLOUD_AGNSS)
+	case LOCATION_EVT_GNSS_ASSISTANCE_REQUEST:
+		LOG_DBG("A-GNSS assistance request received from location library");
+		agnss_request_send(&event_data->agnss_request);
+		break;
+#endif
+	case LOCATION_EVT_RESULT_UNKNOWN:
+		LOG_DBG("Location result unknown");
+		status_send(LOCATION_SEARCH_DONE);
+		break;
 	default:
 		LOG_DBG("Getting location: Unknown event %d", event_data->id);
 		break;

app/src/modules/location/location.h

@@ -9,6 +9,7 @@
 
 #include <zephyr/kernel.h>
 #include <zephyr/zbus/zbus.h>
+#include <modem/location.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,9 +24,21 @@ enum location_msg_type {
 	LOCATION_SEARCH_STARTED = 0x1,
 	LOCATION_SEARCH_DONE,
 	LOCATION_SEARCH_TRIGGER,
+	LOCATION_CLOUD_REQUEST,
+	LOCATION_AGNSS_REQUEST,
 };
 
-#define MSG_TO_LOCATION_TYPE(_msg)	(*(const enum location_msg_type *)_msg)
+/* Structure to pass location data through zbus */
+struct location_msg {
+	enum location_msg_type type;
+	union {
+		struct location_data_cloud cloud_request;
+		struct nrf_modem_gnss_agnss_data_frame agnss_request;
+	};
+};
+
+#define MSG_TO_LOCATION_TYPE(_msg)	(((const struct location_msg *)_msg)->type)
+#define MSG_TO_LOCATION_MSG_PTR(_msg)	(((const struct location_msg *)_msg))
 
 #ifdef __cplusplus
 }