Merge 25Q1 (ab/12770256) to aosp-main-future
Bug: 385190204
Merged-In: Ie2744a58c02b2ac5513583daa324e7a9891a26b0
Change-Id: I1535dc493f7ea63f594540ea33c857e28ce2d39c
diff --git a/Android.bp b/Android.bp
index 78a78ca..49fe6f1 100644
--- a/Android.bp
+++ b/Android.bp
@@ -56,6 +56,72 @@
],
}
+filegroup {
+ name: "contexthub_hal_common_srcs",
+ srcs: [
+ "host/common/file_stream.cc",
+ "host/common/fragmented_load_transaction.cc",
+ "host/common/host_protocol_host.cc",
+ "host/common/log.cc",
+ "host/hal_generic/common/context_hub_v4_impl.cc",
+ "host/hal_generic/common/message_hub_manager.cc",
+ "platform/shared/host_protocol_common.cc",
+ ],
+}
+
+filegroup {
+ name: "contexthub_hal_client_srcs",
+ srcs: [
+ "host/common/hal_client.cc",
+ "host/common/pigweed/hal_channel_output.cc",
+ "host/common/pigweed/hal_rpc_client.cc",
+ "host/common/socket_client.cc",
+ ],
+}
+
+cc_defaults {
+ name: "contexthub_hal_defaults",
+ vendor: true,
+ srcs: [":contexthub_hal_common_srcs"],
+ include_dirs: [
+ "system/chre/host/common/include/",
+ "system/chre/host/hal_generic/aidl/",
+ "system/chre/host/hal_generic/common/",
+ "system/chre/platform/shared/include/",
+ "system/chre/util/include/",
+ ],
+ header_libs: [
+ "chre_api",
+ "chre_flatbuffers",
+ ],
+ shared_libs: [
+ "android.frameworks.stats-V2-ndk",
+ "android.hardware.contexthub-V4-ndk",
+ "chre_atoms_log",
+ "chremetrics-cpp",
+ "libaconfig_storage_read_api_cc",
+ "libbase",
+ "libbinder_ndk",
+ "libcutils",
+ "libjsoncpp",
+ "liblog",
+ "libprotobuf-cpp-lite",
+ "libutils",
+ "server_configurable_flags",
+ ],
+ static_libs: [
+ "chre_flags_c_lib",
+ "chre_metrics_reporter",
+ "event_logger",
+ ],
+ cflags: [
+ "-DCHRE_IS_HOST_BUILD",
+ "-DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4000", // Needed to import CHRE APIs
+ "-Wall",
+ "-Werror",
+ ],
+}
+
cc_library_static {
name: "chre_client",
vendor_available: true,
@@ -469,7 +535,7 @@
"util/include",
],
shared_libs: [
- "android.hardware.contexthub-V3-ndk",
+ "android.hardware.contexthub-V4-ndk",
"libcutils",
"libutils",
],
@@ -528,7 +594,7 @@
"util/include/",
],
static_libs: [
- "android.hardware.contexthub-V3-ndk",
+ "android.hardware.contexthub-V4-ndk",
"chre_flags_c_lib",
"chre_host_common",
"event_logger",
@@ -537,7 +603,7 @@
],
shared_libs: [
"android.frameworks.stats-V2-ndk",
- "android.hardware.contexthub-V3-ndk",
+ "android.hardware.contexthub-V4-ndk",
"chre_atoms_log",
"libaconfig_storage_read_api_cc",
"libbase",
@@ -715,20 +781,17 @@
"platform/shared/pw_trace/include",
"util/include",
],
- cflags: [
- "-DCHRE_ASSERTIONS_ENABLED=true",
- "-DCHRE_BLE_SUPPORT_ENABLED=true",
- "-DCHRE_FILENAME=__FILE__",
- "-DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4096",
- "-DCHRE_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG",
- "-DGTEST",
- ],
header_libs: [
"chre_flatbuffers",
],
static_libs: [
"chre_linux",
"libgmock",
+ "pw_allocator",
+ "pw_containers",
+ ],
+ defaults: [
+ "chre_linux_cflags",
],
sanitize: {
address: true,
@@ -749,27 +812,55 @@
// Lib dependencies for apps and libs using PW_RPC with nanopb.
cc_defaults {
name: "pw_rpc_nanopb_lib_dependencies",
- defaults: [
- "pw_android_common_backends",
- ],
static_libs: [
+ "pw_assert_log",
+ "pw_chrono_stl",
"pw_containers",
+ "pw_log_android",
"pw_protobuf",
"pw_rpc_chre",
"pw_rpc_nanopb_chre",
"pw_status",
"pw_stream",
+ "pw_sync_stl",
+ "pw_thread_stl",
"pw_varint",
],
+ export_static_lib_headers: [
+ "pw_assert_log",
+ "pw_chrono_stl",
+ "pw_log_android",
+ "pw_sync_stl",
+ "pw_thread_stl",
+ ],
+ shared_libs: [
+ "liblog",
+ ],
}
cc_library_static {
name: "pw_rpc_chre",
defaults: [
- "pw_android_common_backends",
"pw_rpc_cflags_chre",
"pw_rpc_defaults",
],
+ static_libs: [
+ "pw_assert_log",
+ "pw_chrono_stl",
+ "pw_log_android",
+ "pw_sync_stl",
+ "pw_thread_stl",
+ ],
+ export_static_lib_headers: [
+ "pw_assert_log",
+ "pw_chrono_stl",
+ "pw_log_android",
+ "pw_sync_stl",
+ "pw_thread_stl",
+ ],
+ shared_libs: [
+ "liblog",
+ ],
host_supported: true,
vendor_available: true,
}
@@ -857,12 +948,19 @@
],
local_include_dirs: [
"platform/shared",
+ "platform/shared/public_platform_ble_pal",
+ "platform/shared/public_platform_debug_dump_manager",
+ "platform/shared/public_platform_gnss_pal",
+ "platform/shared/public_platform_wifi_pal",
+ "platform/shared/public_platform_wwan_pal",
"test/simulation/inc",
],
static_libs: [
"chre_linux",
"chre_pal_linux",
"libprotobuf-c-nano",
+ "pw_allocator",
+ "pw_containers",
],
defaults: [
"chre_linux_cflags",
@@ -882,6 +980,7 @@
"core/ble_request.cc",
"core/ble_request_manager.cc",
"core/ble_request_multiplexer.cc",
+ "core/chre_message_hub_manager.cc",
"core/debug_dump_manager.cc",
"core/event.cc",
"core/event_loop.cc",
@@ -960,6 +1059,11 @@
"platform/linux/include",
"platform/shared/audio_pal/include",
"platform/shared/include",
+ "platform/shared/public_platform_ble_pal",
+ "platform/shared/public_platform_debug_dump_manager",
+ "platform/shared/public_platform_gnss_pal",
+ "platform/shared/public_platform_wifi_pal",
+ "platform/shared/public_platform_wwan_pal",
"platform/shared/sensor_pal/include",
"util/include",
],
@@ -974,6 +1078,7 @@
static_libs: [
"libgmock",
"libgtest",
+ "pw_allocator",
"pw_rpc_chre",
],
host_supported: true,
@@ -989,8 +1094,10 @@
"-DCHRE_FIRST_SUPPORTED_API_VERSION=CHRE_API_VERSION_1_1",
"-DCHRE_GNSS_SUPPORT_ENABLED",
"-DCHRE_LARGE_PAYLOAD_MAX_SIZE=32000",
+ "-DCHRE_MESSAGE_ROUTER_SUPPORT_ENABLED",
"-DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4096",
"-DCHRE_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG",
+ "-DCHRE_PLATFORM_ID=1",
"-DCHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED",
"-DCHRE_SENSORS_SUPPORT_ENABLED",
"-DCHRE_TEST_ASYNC_RESULT_TIMEOUT_NS=300000000",
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..c43fb9d
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,23 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+add_subdirectory(chre_api)
+add_subdirectory(core)
+add_subdirectory(pal)
+add_subdirectory(platform)
+add_subdirectory(util)
+add_subdirectory(variant)
+
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+if(NOT chre_third_party_flatbuffers_LIBRARY)
+ pw_add_error_target(chre_third_party.flatbuffers
+ MESSAGE
+ "Attempted to build chre_third_party.flatbuffers without configuring it "
+ "via chre_third_party_flatbuffers_LIBRARY."
+ )
+else()
+ pw_add_library(chre_third_party.flatbuffers INTERFACE
+ PUBLIC_DEPS
+ "${chre_third_party_flatbuffers_LIBRARY}"
+ )
+endif()
diff --git a/apps/ble_world/ble_world.cc b/apps/ble_world/ble_world.cc
index 9251d87..19b1df5 100644
--- a/apps/ble_world/ble_world.cc
+++ b/apps/ble_world/ble_world.cc
@@ -23,6 +23,7 @@
#define BLE_FILTER_TYPE_SERVICE_DATA 0
#define BLE_FILTER_TYPE_MANUFACTURER_DATA 1
+#define BLE_FILTER_TYPE_BROADCASTER_ADDRESS 2
/**
* @file
@@ -42,8 +43,9 @@
*
* The BLE scanning test can also be configured by filter type. By default, the
* test will filter by service data, but it can be modified to filter by
- * manufacturer data by setting the BLE_FILTER_TYPE flag to
- * BLE_FILTER_TYPE_MANUFACTURER_DATA. It is recommended to use an app that can
+ * manufacturer data or broadcaster address by setting the BLE_FILTER_TYPE flag
+ * to either BLE_FILTER_TYPE_MANUFACTURER_DATA or
+ * BLE_FILTER_TYPE_BROADCASTER_ADDRESS. It is recommended to use an app that can
* create advertisers corresponding to the filters to do the tests.
*/
@@ -52,6 +54,7 @@
namespace {
#endif // CHRE_NANOAPP_INTERNAL
+using chre::ble_constants::kNumBroadcasterFilters;
using chre::ble_constants::kNumManufacturerDataFilters;
using chre::ble_constants::kNumScanFilters;
@@ -96,6 +99,12 @@
LOGE("BLE manufacturer data filters are not supported");
return false;
}
+#elif BLE_FILTER_TYPE == BLE_FILTER_TYPE_BROADCASTER_ADDRESS
+ if ((filterCapabilities & CHRE_BLE_FILTER_CAPABILITIES_BROADCASTER_ADDRESS) ==
+ 0) {
+ LOGE("BLE broadcaster address filters are not supported");
+ return false;
+ }
#else
if ((filterCapabilities & CHRE_BLE_FILTER_CAPABILITIES_SERVICE_DATA) == 0) {
LOGE("BLE service data filters are not supported");
@@ -111,10 +120,18 @@
chreBleGenericFilter genericFilters[kNumManufacturerDataFilters];
chre::createBleManufacturerDataFilter(kNumManufacturerDataFilters,
genericFilters, filter);
+#elif BLE_FILTER_TYPE == BLE_FILTER_TYPE_BROADCASTER_ADDRESS
+ chreBleBroadcasterAddressFilter broadcasterFilters[kNumBroadcasterFilters];
+ if (!chre::createBleScanFilterForAdvertiser(filter, broadcasterFilters,
+ kNumBroadcasterFilters)) {
+ LOGE("Failed to create BLE scan filters for known beacons and advertiser");
+ }
#else
chreBleGenericFilter genericFilters[kNumScanFilters];
- chre::createBleScanFilterForKnownBeaconsV1_9(filter, genericFilters,
- kNumScanFilters);
+ if (!chre::createBleScanFilterForKnownBeaconsV1_9(filter, genericFilters,
+ kNumScanFilters)) {
+ LOGE("Failed to create BLE scan filters for known beacons");
+ }
#endif
return chreBleStartScanAsyncV1_9(CHRE_BLE_SCAN_MODE_BACKGROUND,
gBleBatchDurationMs, &filter, &kScanCookie);
@@ -181,26 +198,27 @@
return static_cast<uint16_t>(data[0] + (data[1] << 8));
}
-void parseAdData(const uint8_t *data, uint16_t size) {
- for (uint16_t i = 0; i < size;) {
- // First byte has the dvertisement data length.
- uint16_t adDataLength = data[i];
+void parseReport(const chreBleAdvertisingReport *report) {
+ for (uint16_t i = 0; i < report->dataLength;) {
+ // First byte has the advertisement data length.
+ uint16_t adDataLength = report->data[i];
// Early termination with zero length advertisement.
if (adDataLength == 0) break;
+
// Log 2 byte UUIDs for service data or manufacturer data AD types.
if (adDataLength < kUuidLengthInBytes) {
i += adDataLength + 1;
continue;
}
- uint8_t adDataType = data[++i];
+ uint8_t adDataType = report->data[++i];
switch (adDataType) {
case kDataTypeServiceData:
LOGD("Service Data UUID: %" PRIx16,
- getUuidInLittleEndian(&data[i + 1]));
+ getUuidInLittleEndian(&report->data[i + 1]));
break;
case kDataTypeManufacturerData:
LOGD("Manufacturer Data UUID: %" PRIx16,
- getUuidInLittleEndian(&data[i + 1]));
+ getUuidInLittleEndian(&report->data[i + 1]));
break;
default:
break;
@@ -208,6 +226,14 @@
// Moves to next advertisement.
i += adDataLength;
}
+ LOGD("application address type 0x%" PRIx8, report->addressType);
+ LOGD("address=%02X:%02X:%02X:%02X:%02X:%02X", report->address[0],
+ report->address[1], report->address[2], report->address[3],
+ report->address[4], report->address[5]);
+ LOGD("direct address=%02X:%02X:%02X:%02X:%02X:%02X", report->directAddress[0],
+ report->directAddress[1], report->directAddress[2],
+ report->directAddress[3], report->directAddress[4],
+ report->directAddress[5]);
}
void handleAsyncResultEvent(const chreAsyncResult *result) {
@@ -229,7 +255,7 @@
event->reports[i].eventTypeAndDataStatus);
LOGD("Timestamp: %" PRIu64 " ms",
event->reports[i].timestamp / chre::kOneMillisecondInNanoseconds);
- parseAdData(event->reports[i].data, event->reports[i].dataLength);
+ parseReport(&event->reports[i]);
}
}
diff --git a/apps/message_world/message_world.cc b/apps/message_world/message_world.cc
index 17c910e..b1495e7 100644
--- a/apps/message_world/message_world.cc
+++ b/apps/message_world/message_world.cc
@@ -16,6 +16,7 @@
#include <cinttypes>
+#include "chre/util/macros.h"
#include "chre/util/nanoapp/log.h"
#include "chre_api/chre.h"
@@ -28,17 +29,21 @@
namespace {
-constexpr uint32_t kMessageType = 1234;
-uint8_t gMessageData[CHRE_MESSAGE_TO_HOST_MAX_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8};
+enum MessageType { kDefault = 1, kCustomReplyMessageSize = 2 };
+
+#ifdef CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED
+constexpr uint32_t gMaxReplyMessageSize = CHRE_LARGE_PAYLOAD_MAX_SIZE;
+#else
+constexpr uint32_t gMaxReplyMessageSize = CHRE_MESSAGE_TO_HOST_MAX_SIZE;
+#endif
+
+uint8_t gMessageData[gMaxReplyMessageSize] = {};
void messageFreeCallback(void *message, size_t messageSize) {
- LOGI(
- "Got message free callback for message @ %p (match? %d) size %zu (match?"
- " %d)",
- message, (message == gMessageData), messageSize,
- (messageSize == sizeof(gMessageData)));
- if (!chreSendEvent(CHRE_EVENT_FIRST_USER_VALUE, nullptr, nullptr,
- chreGetInstanceId())) {
+ LOGI("Got message free callback for message @ %p (%s) size %zu", message,
+ (message == gMessageData) ? "matched" : "unmatched", messageSize);
+ if (!chreSendEvent(CHRE_EVENT_FIRST_USER_VALUE, /* eventData= */ nullptr,
+ /* freeCallback= */ nullptr, chreGetInstanceId())) {
LOGE("Failed to send event");
}
}
@@ -47,31 +52,43 @@
bool nanoappStart() {
LOGI("App started as instance %" PRIu32, chreGetInstanceId());
-
+ // initialize gMessageData
+ for (uint32_t i = 0; i < gMaxReplyMessageSize; ++i) {
+ gMessageData[i] = i % 10;
+ }
bool success = chreSendMessageToHostEndpoint(
- gMessageData, sizeof(gMessageData), kMessageType,
+ gMessageData, sizeof(gMessageData), MessageType::kDefault,
CHRE_HOST_ENDPOINT_BROADCAST, messageFreeCallback);
- LOGI("Sent message to host from start callback, result %d", success);
+ LOGI("Sent message of size %zu to host from start callback: %s",
+ sizeof(gMessageData), success ? "success" : "failure");
return true;
}
void nanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
const void *eventData) {
- if (eventType == CHRE_EVENT_MESSAGE_FROM_HOST) {
- auto *msg = static_cast<const chreMessageFromHostData *>(eventData);
- LOGI("Got message from host with type %" PRIu32 " size %" PRIu32
- " data @ %p hostEndpoint 0x%" PRIx16,
- msg->messageType, msg->messageSize, msg->message, msg->hostEndpoint);
- if (senderInstanceId != CHRE_INSTANCE_ID) {
- LOGE("Message from host came from unexpected instance ID %" PRIu32,
- senderInstanceId);
- }
-
- bool success = chreSendMessageToHostEndpoint(
- gMessageData, sizeof(gMessageData), kMessageType,
- CHRE_HOST_ENDPOINT_BROADCAST, messageFreeCallback);
- LOGI("Result of sending reply: %d", success);
+ if (eventType != CHRE_EVENT_MESSAGE_FROM_HOST) {
+ return;
}
+ auto *msg = static_cast<const chreMessageFromHostData *>(eventData);
+ LOGI("Got message from host with type %" PRIu32 " size %" PRIu32
+ " data @ %p hostEndpoint 0x%" PRIx16,
+ msg->messageType, msg->messageSize, msg->message, msg->hostEndpoint);
+ if (senderInstanceId != CHRE_INSTANCE_ID) {
+ LOGE("Message from host came from unexpected instance ID %" PRIu32,
+ senderInstanceId);
+ }
+
+ uint32_t messageSize = gMaxReplyMessageSize;
+ if (msg->messageType == MessageType::kCustomReplyMessageSize) {
+ messageSize =
+ MIN(messageSize, *(static_cast<const uint32_t *>(msg->message)));
+ }
+
+ bool success = chreSendMessageToHostEndpoint(
+ gMessageData, messageSize, MessageType::kDefault, msg->hostEndpoint,
+ messageFreeCallback);
+ LOGI("Result of sending reply (size=%" PRIu32 "): %s", messageSize,
+ success ? "success" : "failure");
}
void nanoappEnd() {
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.cc b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.cc
index e99c4ea..00dd161 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.cc
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.cc
@@ -114,9 +114,7 @@
HandleMatchAdvReports(adv_reports_cache_);
break;
case CHRE_EVENT_TIMER:
- if (event_data == &ble_scan_keep_alive_timer_id) {
- tracker_storage_.Refresh(tracker_filter_.GetBatchConfig());
- }
+ HandleTimerEvent(event_data);
break;
case CHRE_EVENT_HOST_AWAKE:
HandleHostAwakeEvent();
@@ -213,7 +211,8 @@
}
void AppManager::UpdateBleScanState() {
- if (!filter_.IsEmpty() || !tracker_filter_.IsEmpty() ||
+ if (!filter_.IsEmpty() ||
+ (!tracker_filter_.IsEmpty() && tracker_filter_.IsActive()) ||
!filter_extension_.IsEmpty()) {
ble_scanner_.Restart();
} else {
@@ -631,12 +630,42 @@
chre::kOneMillisecondInNanoseconds;
if (current_time - last_tracker_report_flush_time_nanosec_ >=
flush_threshold_nanosec) {
- LOGI("Flush tracker reports by host awake event.");
+ LOGD("Flush tracker reports by host awake event.");
SendTrackerReportsToHost(tracker_storage_.GetBatchReports());
tracker_storage_.Clear();
}
}
+void AppManager::HandleTimerEvent(const void *event_data) {
+ if (event_data == &ble_scan_keep_alive_timer_id) {
+ tracker_storage_.Refresh(tracker_filter_.GetBatchConfig());
+ } else if (event_data ==
+ tracker_filter_.GetActiveIntervalTimer().GetTimerId()) {
+ // When receive the active interval timer event, set the active state for
+ // tracker scan filter, start the oneshot active window timer, and set the
+ // tracker scan filters from the BLE scanner. Then update the BLE scan state
+ // so that the tracker scan can start properly. The tracker scan will stop
+ // when receive the oneshot active window timer event.
+ tracker_filter_.SetActiveState();
+ tracker_filter_.GetActiveWindowTimer().StartTimer();
+ ble_scanner_.SetTrackerFilters();
+ UpdateBleScanState();
+ } else if (event_data ==
+ tracker_filter_.GetActiveWindowTimer().GetTimerId()) {
+ // When receive the active window timer event, clear the active state for
+ // tracker scan filter, clear the tracker scan filters from the BLE scanner,
+ // and update the BLE scan state so that the tracker scan can stop properly.
+ // The tracker scan will restart when receive the next active interval timer
+ // event. If the tracker filter is empty, no action is needed as the tracker
+ // scan has completely stopped at this point.
+ if (!tracker_filter_.IsEmpty()) {
+ tracker_filter_.ClearActiveState();
+ ble_scanner_.ClearTrackerFilters();
+ UpdateBleScanState();
+ }
+ }
+}
+
void AppManager::OnTrackerStorageFullEvent() {
SendTrackerStorageFullEventToHost();
}
@@ -651,6 +680,12 @@
return false;
}
ble_scanner_.UpdateTrackerFilters(generic_filters);
+ // Set or clear tracker scan filter state before updating BLE scan state.
+ if (tracker_filter_.IsEmpty()) {
+ ble_scanner_.ClearTrackerFilters();
+ } else {
+ ble_scanner_.SetTrackerFilters();
+ }
UpdateBleScanState();
// Send tracker reports to host before clearing the tracker storage if the
// host stops the tracker filter.
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.h b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.h
index 2d74be8..bd324a8 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.h
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/app_manager.h
@@ -125,6 +125,9 @@
// Handles host awake event.
void HandleHostAwakeEvent();
+ // Handles timer event.
+ void HandleTimerEvent(const void *event_data);
+
// Handles tracker filter config request from the host.
bool HandleExtTrackerFilterConfig(
const chreHostEndpointInfo &host_info,
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.cc b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.cc
index 3727a17..27db465 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.cc
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.cc
@@ -213,9 +213,11 @@
generic_filters.push_back(kDefaultGenericFilters[i]);
}
}
- for (auto &tracker_filter : tracker_filters_) {
- if (!ContainsFilter(generic_filters, tracker_filter)) {
- generic_filters.push_back(tracker_filter);
+ if (is_tracker_filter_enabled_) {
+ for (auto &tracker_filter : tracker_filters_) {
+ if (!ContainsFilter(generic_filters, tracker_filter)) {
+ generic_filters.push_back(tracker_filter);
+ }
}
}
for (auto &oem_generic_filters : generic_filters_list_) {
@@ -253,7 +255,9 @@
} else {
LOGE("Failed to stop BLE scan");
}
- StopKeepAliveTimer();
+ if (tracker_filters_.empty()) {
+ StopKeepAliveTimer();
+ }
}
bool BleScanner::UpdateFilters(
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.h b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.h
index 7418ef1..af2f45f 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.h
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/ble_scanner.h
@@ -115,6 +115,16 @@
is_default_generic_filter_enabled_ = false;
}
+ // Sets tracker filters.
+ void SetTrackerFilters() {
+ is_tracker_filter_enabled_ = true;
+ }
+
+ // Clears tracker filters.
+ void ClearTrackerFilters() {
+ is_tracker_filter_enabled_ = false;
+ }
+
// Returns whether the filter list contains the given filter.
bool ContainsFilter(const chre::DynamicVector<chreBleGenericFilter> &filters,
const chreBleGenericFilter &src);
@@ -146,6 +156,9 @@
// Whether default generic filter is enabled.
bool is_default_generic_filter_enabled_ = false;
+ // Whether tracker filter is enabled.
+ bool is_tracker_filter_enabled_ = false;
+
// Current report delay for BLE batch scan
uint32_t report_delay_ms_ = 0;
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/proto/nearby_extension.proto b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/proto/nearby_extension.proto
index 873388a..b0d9bd1 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/proto/nearby_extension.proto
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/proto/nearby_extension.proto
@@ -115,6 +115,19 @@
// disables the opportunistic flush.
optional uint32 opportunistic_flush_threshold_time_ms = 8
[default = 4294967295];
+
+ // Active interval for tracker scan filter. The tracker scan filter is
+ // enabled at the beginning of the active interval and disabled at the end
+ // of the active window. This creates a toggle effect for the tracker scan
+ // filter and reduces the BLE scan power consumption. If the interval and
+ // window are not set by host, the default values are 0, and the tracker
+ // scan filter is always enabled.
+ // The active interval must be greater than the active window so that the
+ // scan toggling can function properly.
+ optional uint32 active_interval_ms = 9 [default = 0];
+
+ // Active window for tracker scan filter.
+ optional uint32 active_window_ms = 10 [default = 0];
}
message FlushTrackerReports {}
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.cc b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.cc
new file mode 100644
index 0000000..ee857ed
--- /dev/null
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.cc
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "location/lbs/contexthub/nanoapps/nearby/timer.h"
+
+#include <chre.h>
+
+#include "third_party/contexthub/chre/util/include/chre/util/nanoapp/log.h"
+#include "third_party/contexthub/chre/util/include/chre/util/time.h"
+
+#define LOG_TAG "[NEARBY][TIMER]"
+
+namespace nearby {
+
+bool Timer::StartTimer() {
+ if (duration_ms_ == 0) {
+ LOGD("Timer is not started. Timer duration is 0.");
+ return false;
+ }
+ if (!is_one_shot_ && timer_id_ != CHRE_TIMER_INVALID) {
+ chreTimerCancel(timer_id_);
+ timer_id_ = CHRE_TIMER_INVALID;
+ }
+ timer_id_ = chreTimerSet(duration_ms_ * chre::kOneMillisecondInNanoseconds,
+ &timer_id_, /*oneShot=*/is_one_shot_);
+ if (timer_id_ == CHRE_TIMER_INVALID) {
+ LOGE("Error in configuring timer.");
+ return false;
+ }
+ return true;
+}
+
+bool Timer::StopTimer() {
+ if (timer_id_ == CHRE_TIMER_INVALID) {
+ LOGD("Timer is already stopped.");
+ return false;
+ }
+ if (!chreTimerCancel(timer_id_)) {
+ LOGW(
+ "Error in stopping timer. For a one-shot timer, it may have just "
+ "fired or expired.");
+ return false;
+ }
+ timer_id_ = CHRE_TIMER_INVALID;
+ return true;
+}
+
+} // namespace nearby
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.h b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.h
new file mode 100644
index 0000000..600ed9f
--- /dev/null
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/timer.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LOCATION_LBS_CONTEXTHUB_NANOAPPS_NEARBY_TIMER_H_
+#define LOCATION_LBS_CONTEXTHUB_NANOAPPS_NEARBY_TIMER_H_
+
+#include <cstdint>
+
+#include "chre_api/chre.h"
+
+namespace nearby {
+
+class Timer {
+ public:
+ // Constructs timer.
+ explicit Timer(bool is_one_shot) : is_one_shot_(is_one_shot) {}
+
+ // Sets timer duration in milliseconds.
+ void SetDurationMs(uint32_t duration_ms) {
+ duration_ms_ = duration_ms;
+ }
+
+ // Starts timer.
+ bool StartTimer();
+
+ // Stops timer.
+ bool StopTimer();
+
+ // Returns timer id.
+ const uint32_t *GetTimerId() {
+ return &timer_id_;
+ }
+
+ private:
+ uint32_t timer_id_ = CHRE_TIMER_INVALID;
+ uint32_t duration_ms_ = 0;
+ bool is_one_shot_;
+};
+
+} // namespace nearby
+
+#endif // LOCATION_LBS_CONTEXTHUB_NANOAPPS_NEARBY_TIMER_H_
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.cc b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.cc
index e072b7a..3dbf1fd 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.cc
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.cc
@@ -1,5 +1,6 @@
#include "location/lbs/contexthub/nanoapps/nearby/tracker_filter.h"
+#include <inttypes.h>
#include <cstddef>
#include <cstdint>
#include <cstring>
@@ -51,6 +52,10 @@
}
scan_filter_config_.hardware_filters = std::move(hardware_filters);
scan_filter_config_.rssi_threshold = filter_config.rssi_threshold;
+ scan_filter_config_.active_interval_ms = filter_config.active_interval_ms;
+ scan_filter_config_.active_window_ms = filter_config.active_window_ms;
+ ConfigureActiveState();
+ ConfigureScanControlTimers();
// Sets batch configuration
batch_config_.sample_interval_ms = filter_config.sample_interval_ms;
batch_config_.max_tracker_count = filter_config.max_tracker_count;
@@ -62,6 +67,42 @@
filter_config.opportunistic_flush_threshold_time_ms;
}
+void TrackerFilter::ConfigureActiveState() {
+ if (!scan_filter_config_.hardware_filters.empty()) {
+ SetActiveState();
+ } else {
+ ClearActiveState();
+ }
+}
+
+void TrackerFilter::ConfigureScanControlTimers() {
+ // The timer based scan is only enabled when the hardware scan filters are not
+ // empty and the active window and interval are valid. The active interval
+ // must be greater than the active window so that the timer based scan can
+ // function properly.
+ if (!scan_filter_config_.hardware_filters.empty() &&
+ scan_filter_config_.active_window_ms > 0) {
+ if (scan_filter_config_.active_interval_ms <=
+ scan_filter_config_.active_window_ms) {
+ LOGE("Invalid active interval %" PRIu32
+ " ms, must be greater than active window %" PRIu32 " ms.",
+ scan_filter_config_.active_interval_ms,
+ scan_filter_config_.active_window_ms);
+ return;
+ }
+ // Sets active interval and window timer duration.
+ active_interval_timer_.SetDurationMs(
+ scan_filter_config_.active_interval_ms);
+ active_window_timer_.SetDurationMs(scan_filter_config_.active_window_ms);
+ // Starts active interval and window timers.
+ if (active_interval_timer_.StartTimer()) {
+ active_window_timer_.StartTimer();
+ }
+ } else if (scan_filter_config_.hardware_filters.empty()) {
+ active_interval_timer_.StopTimer();
+ }
+}
+
void TrackerFilter::MatchAndSave(
const chre::DynamicVector<chreBleAdvertisingReport> &ble_adv_reports,
TrackerStorage &tracker_storage) {
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.h b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.h
index ec30279..ef07856 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.h
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_filter.h
@@ -1,11 +1,14 @@
#ifndef LOCATION_LBS_CONTEXTHUB_NANOAPPS_NEARBY_TRACKER_FILTER_H_
#define LOCATION_LBS_CONTEXTHUB_NANOAPPS_NEARBY_TRACKER_FILTER_H_
+#include <stdbool.h>
+
#include <cstdint>
#include "chre_api/chre.h"
#include "location/lbs/contexthub/nanoapps/nearby/byte_array.h"
#include "location/lbs/contexthub/nanoapps/nearby/proto/nearby_extension.nanopb.h"
+#include "location/lbs/contexthub/nanoapps/nearby/timer.h"
#include "location/lbs/contexthub/nanoapps/nearby/tracker_storage.h"
#include "third_party/contexthub/chre/util/include/chre/util/dynamic_vector.h"
@@ -14,6 +17,15 @@
struct TrackerScanFilterConfig {
chre::DynamicVector<chreBleGenericFilter> hardware_filters;
int8_t rssi_threshold = CHRE_BLE_RSSI_THRESHOLD_NONE;
+ // Active interval for tracker scan filter. The tracker scan filter is enabled
+ // at the beginning of the active interval and disabled at the end of the
+ // active window. This creates a toggle effect for the tracker scan filter and
+ // reduces the BLE scan power consumption. If the interval and window are not
+ // set by host, the default values are 0, and the tracker scan filter is
+ // always enabled.
+ uint32_t active_interval_ms;
+ // Active window for tracker scan filter.
+ uint32_t active_window_ms;
};
class TrackerFilter {
@@ -60,10 +72,47 @@
static bool EncodeTrackerReport(TrackerReport &tracker_report,
ByteArray data_buf, size_t *encoded_size);
+ // Sets tracker scan filter active state.
+ void SetActiveState() {
+ is_active_ = true;
+ }
+
+ // Clears tracker scan filter active state.
+ void ClearActiveState() {
+ is_active_ = false;
+ }
+
+ // Returns whether tracker scan filter is active.
+ bool IsActive() {
+ return is_active_;
+ }
+
+ Timer &GetActiveIntervalTimer() {
+ return active_interval_timer_;
+ }
+
+ Timer &GetActiveWindowTimer() {
+ return active_window_timer_;
+ }
+
private:
TrackerScanFilterConfig scan_filter_config_;
TrackerBatchConfig batch_config_;
chreHostEndpointInfo host_info_;
+ // whether the tracker scan filter is active.
+ bool is_active_ = false;
+
+ // Configures tracker scan filter active state.
+ void ConfigureActiveState();
+
+ // Configures tracker scan filter control timers when updating scan filter and
+ // batch configurations.
+ void ConfigureScanControlTimers();
+
+ // Timer for tracker scan filter active interval.
+ Timer active_interval_timer_ = Timer(false);
+ // Timer for tracker scan filter active window.
+ Timer active_window_timer_ = Timer(true);
};
} // namespace nearby
diff --git a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_storage.h b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_storage.h
index 73a03b2..75eb103 100644
--- a/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_storage.h
+++ b/apps/nearby/location/lbs/contexthub/nanoapps/nearby/tracker_storage.h
@@ -22,18 +22,18 @@
struct TrackerBatchConfig {
// Minimum sampling interval to update tracker history.
- uint32_t sample_interval_ms;
+ uint32_t sample_interval_ms = {60000};
// Maximum number of tracker reports that can be stored in storage.
- uint32_t max_tracker_count;
+ uint32_t max_tracker_count = {30};
// Notification threshold of the number of tracker reports, which should be
// equal to or smaller than max_tracker_count.
- uint32_t notify_threshold_tracker_count;
+ uint32_t notify_threshold_tracker_count = {28};
// Maximum number of tracker histories that can be stored in tracker report.
- uint32_t max_history_count;
+ uint32_t max_history_count = {20};
// Timeout for tracker history to be considered lost.
- uint32_t lost_timeout_ms;
+ uint32_t lost_timeout_ms = {60000};
// Time based threshold for opportunistic flush of tracker reports.
- uint32_t opportunistic_flush_threshold_time_ms;
+ uint32_t opportunistic_flush_threshold_time_ms = {4294967295};
};
enum class TrackerState {
diff --git a/apps/sensor_test/Makefile b/apps/sensor_test/Makefile
new file mode 100644
index 0000000..d402f68
--- /dev/null
+++ b/apps/sensor_test/Makefile
@@ -0,0 +1,41 @@
+#
+# Sensor World Nanoapp Makefile
+#
+
+# Environment Checks ###########################################################
+
+ifeq ($(CHRE_PREFIX),)
+ifneq ($(ANDROID_BUILD_TOP),)
+CHRE_PREFIX = $(ANDROID_BUILD_TOP)/system/chre
+else
+$(error "You must run 'lunch' to setup ANDROID_BUILD_TOP, or explicitly define \
+ the CHRE_PREFIX environment variable to point to the CHRE root \
+ directory.")
+endif
+endif
+
+# Nanoapp Configuration ########################################################
+
+NANOAPP_NAME = sensor_test
+NANOAPP_ID = 0x0123456789000016
+NANOAPP_VERSION = 0x00000001
+
+NANOAPP_NAME_STRING = \"Sensor\ Test\"
+
+# Common Compiler Flags ########################################################
+
+# Include paths.
+COMMON_CFLAGS += -I.
+COMMON_CFLAGS += -I$(CHRE_PREFIX)/util/include
+
+# Defines.
+COMMON_CFLAGS += -DNANOAPP_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG
+COMMON_CFLAGS += -DCHRE_ASSERTIONS_ENABLED
+
+# Common Source Files ##########################################################
+
+COMMON_SRCS += sensor_test.cc
+
+# Makefile Includes ############################################################
+
+include $(CHRE_PREFIX)/build/nanoapp/app.mk
diff --git a/apps/sensor_test/sensor_test.cc b/apps/sensor_test/sensor_test.cc
new file mode 100644
index 0000000..0aa612e
--- /dev/null
+++ b/apps/sensor_test/sensor_test.cc
@@ -0,0 +1,582 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cinttypes>
+
+#include "chre/util/macros.h"
+#include "chre/util/nanoapp/log.h"
+#include "chre/util/time.h"
+#include "chre_api/chre.h"
+
+#define LOG_TAG "[SensorTest]"
+
+#ifdef CHRE_NANOAPP_INTERNAL
+namespace chre {
+namespace {
+#endif // CHRE_NANOAPP_INTERNAL
+
+using chre::kOneMillisecondInNanoseconds;
+using chre::Milliseconds;
+using chre::Seconds;
+
+namespace {
+
+//! Enable BreakIt test mode.
+// In BreakIt test mode, a timer will be set periodically to randomly
+// enable/disable each sensor.
+constexpr bool kBreakIt = false;
+constexpr Milliseconds kBreakItPeriod = Milliseconds(2000);
+uint32_t gBreakItTimerHandle;
+
+//! Enable chreSensorFlushAsync test
+// When enabled, SensorTest will set a timer to invoke
+// chreSensorFlushAsync(sensors[kFlushSensorIndex].handle)
+// halfway through sensors[kFlushSensorIndex].latency
+//
+// If CHRE_EVENT_SENSOR_FLUSH_COMPLETE is not received before
+// kFlushItTimeout expires, an error message will be logged.
+constexpr bool kFlushIt = true;
+constexpr uint32_t kFlushCookie = 0xdeadbeef;
+constexpr uint32_t kFlushSensorIndex = 0; // CHRE_SENSOR_TYPE_ACCELEROMETER
+uint32_t gFlushItTimerHandle;
+
+constexpr Milliseconds kFlushItTimeout = Milliseconds(5000);
+uint32_t gFlushItTimeoutTimerHandle;
+
+//! Whether to enable sensor event logging or not.
+constexpr bool kEnableSensorEventLogging = true;
+
+//! Enable/disable all sensors by default.
+// This allows disabling all sensens by default and enabling only targeted
+// sensors for testing by locally overriding 'enable' field in SensorState.
+// Note that enabling BreakIt test disables all sensors at init by default.
+constexpr bool kEnableDefault = !kBreakIt;
+
+struct SensorState {
+ const uint8_t type;
+ const uint8_t sensorIndex;
+ uint32_t handle;
+ bool isInitialized;
+ bool enable;
+ uint64_t interval; // nsec
+ uint64_t latency; // nsec
+ chreSensorInfo info;
+};
+
+SensorState sensors[] = {
+ {
+ .type = CHRE_SENSOR_TYPE_ACCELEROMETER,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = false, // InstantMotion is triggered by Prox
+ .interval = CHRE_SENSOR_INTERVAL_DEFAULT,
+ .latency = CHRE_SENSOR_LATENCY_DEFAULT,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_STATIONARY_DETECT,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = false, // StationaryDetect is triggered by Prox
+ .interval = CHRE_SENSOR_INTERVAL_DEFAULT,
+ .latency = CHRE_SENSOR_LATENCY_DEFAULT,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_GYROSCOPE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_PRESSURE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(200).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_LIGHT,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(200).toRawNanoseconds(),
+ .latency = 0,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_PROXIMITY,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(200).toRawNanoseconds(),
+ .latency = 0,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_STEP_DETECT,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = CHRE_SENSOR_INTERVAL_DEFAULT,
+ .latency = CHRE_SENSOR_LATENCY_ASAP,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_STEP_COUNTER,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = CHRE_SENSOR_INTERVAL_DEFAULT,
+ .latency = CHRE_SENSOR_LATENCY_ASAP,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Seconds(2).toRawNanoseconds(),
+ .latency = 0,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Seconds(2).toRawNanoseconds(),
+ .latency = 0,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Seconds(2).toRawNanoseconds(),
+ .latency = 0,
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+ {
+ .type = CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD,
+ .sensorIndex = 0,
+ .handle = 0,
+ .isInitialized = false,
+ .enable = kEnableDefault,
+ .interval = Milliseconds(80).toRawNanoseconds(),
+ .latency = Seconds(4).toRawNanoseconds(),
+ .info = {},
+ },
+};
+
+// Conditional logging macro
+#define CLOGI(fmt, ...) \
+ do { \
+ if (kEnableSensorEventLogging) { \
+ LOGI(fmt, ##__VA_ARGS__); \
+ } \
+ } while (0);
+
+// Helpers for testing InstantMotion and StationaryDetect
+enum class MotionMode {
+ Instant,
+ Stationary,
+};
+
+// Storage to help access InstantMotion and StationaryDetect sensor handle and
+// info
+size_t motionSensorIndices[2];
+MotionMode motionMode = MotionMode::Instant;
+
+size_t getMotionSensorIndex() {
+ motionMode = (motionMode == MotionMode::Instant) ? MotionMode::Stationary
+ : MotionMode::Instant;
+ return motionSensorIndices[static_cast<size_t>(motionMode)];
+}
+
+//! Used to loop through all sensors to query sensor sampling status.
+size_t statusIndex = 0;
+
+// Obtains 16-bit pseudo-random numbers.
+uint16_t getNextLfsrState() {
+ // 15-bit LFSR with feedback polynomial x^15 + x^14 + 1 gives us a
+ // pseudo-random sequence over all 32767 possible values
+ static uint16_t lfsr = 0x1337;
+ uint16_t nextBit = ((lfsr << 14) ^ (lfsr << 13)) & 0x4000;
+ lfsr = nextBit | (lfsr >> 1);
+
+ return lfsr;
+}
+
+const char *getSensorName(uint32_t sensorHandle) {
+ for (size_t i = 0; i < ARRAY_SIZE(sensors); i++) {
+ if (sensors[i].handle == sensorHandle) {
+ return sensors[i].info.sensorName;
+ }
+ }
+ return nullptr;
+}
+
+void handleTimerEvent(const uint32_t *ev) {
+ if (*ev == gFlushItTimerHandle) {
+ LOGI("FlushIt Timer Fired");
+ if (chreSensorFlushAsync(sensors[kFlushSensorIndex].handle,
+ &kFlushCookie)) {
+ gFlushItTimeoutTimerHandle =
+ chreTimerSet(kFlushItTimeout.toRawNanoseconds(),
+ &gFlushItTimeoutTimerHandle, true /* oneShot */);
+ } else {
+ LOGE("chreSensorFlushAsync failed");
+ }
+
+ } else if (*ev == gFlushItTimeoutTimerHandle) {
+ LOGE("chreSensorFlushAsync Timeout");
+
+ } else if (*ev == gBreakItTimerHandle) {
+ for (size_t i = 0; i < ARRAY_SIZE(sensors); i++) {
+ SensorState &sensor = sensors[i];
+
+ bool enable = getNextLfsrState() & 0x1;
+ if (sensor.isInitialized && sensor.enable != enable) {
+ sensor.enable = enable;
+
+ bool status;
+ if (!enable) {
+ status = chreSensorConfigureModeOnly(sensor.handle,
+ CHRE_SENSOR_CONFIGURE_MODE_DONE);
+ } else {
+ enum chreSensorConfigureMode mode =
+ sensor.info.isOneShot ? CHRE_SENSOR_CONFIGURE_MODE_ONE_SHOT
+ : CHRE_SENSOR_CONFIGURE_MODE_CONTINUOUS;
+ status = chreSensorConfigure(sensor.handle, mode, sensor.interval,
+ sensor.latency);
+ }
+
+ LOGI("Configure [enable %d, status %d]: %s", enable, status,
+ sensor.info.sensorName);
+ }
+ }
+
+ gBreakItTimerHandle =
+ chreTimerSet(kBreakItPeriod.toRawNanoseconds(), &gBreakItTimerHandle,
+ true /* oneShot */);
+ }
+}
+
+void handleThreeAxisEvent(const chreSensorThreeAxisData *ev,
+ uint16_t eventType) {
+ const auto header = ev->header;
+ const auto *data = ev->readings;
+ const auto accuracy = header.accuracy;
+ uint64_t sampleTime = header.baseTimestamp;
+ uint64_t chreTime = chreGetTime();
+
+ float x = 0, y = 0, z = 0;
+ for (size_t i = 0; i < header.readingCount; i++) {
+ x += data[i].v[0];
+ y += data[i].v[1];
+ z += data[i].v[2];
+ sampleTime += data[i].timestampDelta;
+ }
+ x /= header.readingCount;
+ y /= header.readingCount;
+ z /= header.readingCount;
+
+ CLOGI("%s, %d samples: %f %f %f, accuracy: %u, t=%" PRIu64 " ms",
+ getSensorName(header.sensorHandle), header.readingCount,
+ static_cast<double>(x), static_cast<double>(y), static_cast<double>(z),
+ accuracy, header.baseTimestamp / kOneMillisecondInNanoseconds);
+
+ if (eventType == CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA) {
+ CLOGI("UncalGyro time: first %" PRIu64 " last %" PRIu64 " chre %" PRIu64
+ " delta [%" PRId64 ", %" PRId64 "]ms",
+ header.baseTimestamp, sampleTime, chreTime,
+ static_cast<int64_t>(header.baseTimestamp - chreTime) /
+ static_cast<int64_t>(kOneMillisecondInNanoseconds),
+ static_cast<int64_t>(sampleTime - chreTime) /
+ static_cast<int64_t>(kOneMillisecondInNanoseconds));
+ }
+}
+
+void handleFloatEvent(const chreSensorFloatData *ev) {
+ const auto header = ev->header;
+
+ float v = 0;
+ for (size_t i = 0; i < header.readingCount; i++) {
+ v += ev->readings[i].value;
+ }
+ v /= header.readingCount;
+
+ CLOGI("%s, %d samples: %f, accuracy = %u, t=%" PRIu64 " ms",
+ getSensorName(header.sensorHandle), header.readingCount,
+ static_cast<double>(v), header.accuracy,
+ header.baseTimestamp / kOneMillisecondInNanoseconds);
+}
+
+void handleProximityEvent(const chreSensorByteData *ev) {
+ const auto header = ev->header;
+ const auto reading = ev->readings[0];
+ uint64_t sampleTime = header.baseTimestamp;
+ uint64_t chreTime = chreGetTime();
+
+ CLOGI("%s, %d samples: isNear %d, invalid %d, accuracy: %u",
+ getSensorName(header.sensorHandle), header.readingCount, reading.isNear,
+ reading.invalid, header.accuracy);
+
+ CLOGI("Prox time: sample %" PRIu64 " chre %" PRIu64 " delta %" PRId64 "ms",
+ header.baseTimestamp, chreTime,
+ static_cast<int64_t>(sampleTime - chreTime) / 1000000);
+
+ // Enable InstantMotion and StationaryDetect alternatively on near->far.
+ if (reading.isNear == 0 && !kBreakIt) {
+ size_t motionSensorIndex = getMotionSensorIndex();
+ bool status = chreSensorConfigure(
+ sensors[motionSensorIndex].handle, CHRE_SENSOR_CONFIGURE_MODE_ONE_SHOT,
+ CHRE_SENSOR_INTERVAL_DEFAULT, CHRE_SENSOR_LATENCY_DEFAULT);
+ LOGI("Requested %s: %s", sensors[motionSensorIndex].info.sensorName,
+ status ? "success" : "failure");
+ }
+
+ // Exercise chreGetSensorSamplingStatus on one sensor on near->far.
+ if (sensors[statusIndex].isInitialized && reading.isNear == 0) {
+ struct chreSensorSamplingStatus status;
+ bool success =
+ chreGetSensorSamplingStatus(sensors[statusIndex].handle, &status);
+ LOGI("%s success %d: enabled %d interval %" PRIu64 " latency %" PRIu64,
+ sensors[statusIndex].info.sensorName, success, status.enabled,
+ status.interval, status.latency);
+ }
+ statusIndex = (statusIndex + 1) % ARRAY_SIZE(sensors);
+}
+
+} // namespace
+
+bool nanoappStart() {
+ LOGI("App started on platform ID %" PRIx64, chreGetPlatformId());
+
+ for (size_t i = 0; i < ARRAY_SIZE(sensors); i++) {
+ SensorState &sensor = sensors[i];
+ sensor.isInitialized =
+ chreSensorFind(sensor.type, sensor.sensorIndex, &sensor.handle);
+ LOGI("Sensor %zu initialized: %s with handle %" PRIu32, i,
+ sensor.isInitialized ? "true" : "false", sensor.handle);
+
+ if (sensor.type == CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT) {
+ motionSensorIndices[static_cast<size_t>(MotionMode::Instant)] = i;
+ } else if (sensor.type == CHRE_SENSOR_TYPE_STATIONARY_DETECT) {
+ motionSensorIndices[static_cast<size_t>(MotionMode::Stationary)] = i;
+ }
+
+ if (sensor.isInitialized) {
+ // Get sensor info
+ chreSensorInfo &info = sensor.info;
+ bool infoStatus = chreGetSensorInfo(sensor.handle, &info);
+ if (infoStatus) {
+ LOGI("SensorInfo: %s, Type=%" PRIu8
+ " OnChange=%d OneShot=%d Passive=%d "
+ "minInterval=%" PRIu64 "nsec",
+ info.sensorName, info.sensorType, info.isOnChange, info.isOneShot,
+ info.supportsPassiveMode, info.minInterval);
+ } else {
+ LOGE("chreGetSensorInfo failed");
+ }
+
+ // Subscribe to sensors
+ if (sensor.enable) {
+ float odrHz = 1e9f / static_cast<float>(sensor.interval);
+ float latencySec = static_cast<float>(sensor.latency) / 1e9f;
+ bool status = chreSensorConfigure(sensor.handle,
+ CHRE_SENSOR_CONFIGURE_MODE_CONTINUOUS,
+ sensor.interval, sensor.latency);
+ LOGI("Requested data: odr %f Hz, latency %f sec, %s",
+ static_cast<double>(odrHz), static_cast<double>(latencySec),
+ status ? "success" : "failure");
+ }
+ }
+ }
+
+ // Set timer for BreakIt test.
+ if (kBreakIt) {
+ gBreakItTimerHandle =
+ chreTimerSet(kBreakItPeriod.toRawNanoseconds(), &gBreakItTimerHandle,
+ true /* oneShot */);
+ }
+
+ if (kFlushIt) {
+ // Trigger a flush half way through the target sensor latency
+ gFlushItTimerHandle =
+ chreTimerSet(sensors[kFlushSensorIndex].latency / 2,
+ &gFlushItTimerHandle, true /* oneShot */);
+ }
+
+ return true;
+}
+
+void nanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
+ const void *eventData) {
+ UNUSED_VAR(senderInstanceId);
+
+ switch (eventType) {
+ case CHRE_EVENT_SENSOR_ACCELEROMETER_DATA:
+ case CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_DATA:
+ case CHRE_EVENT_SENSOR_GYROSCOPE_DATA:
+ case CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA:
+ case CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_DATA:
+ case CHRE_EVENT_SENSOR_UNCALIBRATED_GEOMAGNETIC_FIELD_DATA:
+ handleThreeAxisEvent(
+ static_cast<const chreSensorThreeAxisData *>(eventData), eventType);
+ break;
+
+ case CHRE_EVENT_SENSOR_PRESSURE_DATA:
+ case CHRE_EVENT_SENSOR_LIGHT_DATA:
+ case CHRE_EVENT_SENSOR_ACCELEROMETER_TEMPERATURE_DATA:
+ case CHRE_EVENT_SENSOR_GYROSCOPE_TEMPERATURE_DATA:
+ case CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_TEMPERATURE_DATA:
+ handleFloatEvent(static_cast<const chreSensorFloatData *>(eventData));
+ break;
+
+ case CHRE_EVENT_SENSOR_PROXIMITY_DATA:
+ handleProximityEvent(static_cast<const chreSensorByteData *>(eventData));
+ break;
+
+ case CHRE_EVENT_SENSOR_INSTANT_MOTION_DETECT_DATA:
+ case CHRE_EVENT_SENSOR_STATIONARY_DETECT_DATA:
+ case CHRE_EVENT_SENSOR_STEP_DETECT_DATA: {
+ const auto *ev = static_cast<const chreSensorOccurrenceData *>(eventData);
+ const auto header = ev->header;
+
+ CLOGI("%s, %d samples, accuracy: %u", getSensorName(header.sensorHandle),
+ header.readingCount, header.accuracy);
+ break;
+ }
+
+ case CHRE_EVENT_SENSOR_STEP_COUNTER_DATA: {
+ const auto *ev = static_cast<const chreSensorUint64Data *>(eventData);
+ const auto header = ev->header;
+ const uint64_t reading = ev->readings[header.readingCount - 1].value;
+
+ CLOGI("%s, %" PRIu16 " samples: latest %" PRIu64,
+ getSensorName(header.sensorHandle), header.readingCount, reading);
+ break;
+ }
+
+ case CHRE_EVENT_SENSOR_SAMPLING_CHANGE: {
+ const auto *ev =
+ static_cast<const chreSensorSamplingStatusEvent *>(eventData);
+
+ CLOGI("Sampling Change: handle %" PRIu32 ", status: interval %" PRIu64
+ " latency %" PRIu64 " enabled %d",
+ ev->sensorHandle, ev->status.interval, ev->status.latency,
+ ev->status.enabled);
+ break;
+ }
+
+ case CHRE_EVENT_TIMER:
+ if (kBreakIt || kFlushIt) {
+ handleTimerEvent(static_cast<const uint32_t *>(eventData));
+ } else {
+ LOGE("Timer event received with kBreakIt and kFlushIt disabled");
+ }
+ break;
+
+ case CHRE_EVENT_SENSOR_FLUSH_COMPLETE: {
+ const auto *ev =
+ static_cast<const chreSensorFlushCompleteEvent *>(eventData);
+ chreTimerCancel(gFlushItTimeoutTimerHandle);
+
+ LOGI("Flush Complete: handle %" PRIu32 ", errorCode: %d",
+ ev->sensorHandle, ev->errorCode);
+ break;
+ }
+
+ default:
+ LOGW("Unhandled event %d", eventType);
+ break;
+ }
+}
+
+void nanoappEnd() {
+ LOGI("Stopped");
+}
+
+#ifdef CHRE_NANOAPP_INTERNAL
+} // anonymous namespace
+} // namespace chre
+
+#include "chre/platform/static_nanoapp_init.h"
+#include "chre/util/nanoapp/app_id.h"
+#include "chre/util/system/napp_permissions.h"
+
+CHRE_STATIC_NANOAPP_INIT(SensorWorld, chre::kSensorWorldAppId, 0,
+ chre::NanoappPermissions::CHRE_PERMS_NONE);
+#endif // CHRE_NANOAPP_INTERNAL
diff --git a/apps/sensor_test/sensor_test.mk b/apps/sensor_test/sensor_test.mk
new file mode 100644
index 0000000..6b6f44e
--- /dev/null
+++ b/apps/sensor_test/sensor_test.mk
@@ -0,0 +1,12 @@
+#
+# Sensor World Makefile
+#
+
+# Common Compiler Flags ########################################################
+
+# Include paths.
+COMMON_CFLAGS += -Iapps/sensor_test/include
+
+# Common Source Files ##########################################################
+
+COMMON_SRCS += apps/sensor_test/sensor_test.cc
diff --git a/apps/test/chqts/src/general_test/basic_audio_test.cc b/apps/test/chqts/src/general_test/basic_audio_test.cc
index 8076598..6c2b7a0 100644
--- a/apps/test/chqts/src/general_test/basic_audio_test.cc
+++ b/apps/test/chqts/src/general_test/basic_audio_test.cc
@@ -261,10 +261,7 @@
struct chreAudioSource source;
constexpr uint32_t kRequiredAudioHandle = 0;
// If the DUT supports CHRE audio, then audio handle 0 is required to be
- // valid. There is the risk that the chreAudioGetSource function might
- // legitimately fail however - we should replace this function when CHRE
- // audio capabilities in b/185155280 are implemented.
- // TODO (b/185155280): fix this query
+ // valid.
return chreAudioGetSource(kRequiredAudioHandle, &source);
}
} // anonymous namespace
diff --git a/apps/test/chqts/src/general_test/basic_ble_test.cc b/apps/test/chqts/src/general_test/basic_ble_test.cc
index 4d01722..e27432f 100644
--- a/apps/test/chqts/src/general_test/basic_ble_test.cc
+++ b/apps/test/chqts/src/general_test/basic_ble_test.cc
@@ -15,13 +15,14 @@
*/
#include <general_test/basic_ble_test.h>
-
#include <shared/send_message.h>
#include "chre/util/nanoapp/ble.h"
+#include "chre/util/nanoapp/log.h"
#include "chre/util/time.h"
#include "chre_api/chre.h"
+#define LOG_TAG "[GeneralTest][Ble]"
/*
* Test to check expected functionality of the CHRE BLE APIs.
*/
@@ -83,8 +84,15 @@
}
void BasicBleTest::handleBleAsyncResult(const chreAsyncResult *result) {
- if (result == nullptr || !result->success) {
+ if (result == nullptr) {
+ sendFatalFailureToHost("Received null BLE async result");
+ return;
+ }
+ if (!result->success) {
+ LOGE("Received unsuccessful BLE async result, error code %" PRIu8,
+ result->errorCode);
sendFatalFailureToHost("Received unsuccessful BLE async result");
+ return;
}
switch (result->requestType) {
diff --git a/apps/test/common/chre_api_test/rpc/chre_api_test.pwpb_options b/apps/test/common/chre_api_test/rpc/chre_api_test.pwpb_options
new file mode 100644
index 0000000..6cc7b0b
--- /dev/null
+++ b/apps/test/common/chre_api_test/rpc/chre_api_test.pwpb_options
@@ -0,0 +1,12 @@
+chre.rpc.ChreGetSensorInfoOutput.sensorName max_size:100
+chre.rpc.ChreAudioGetSourceOutput.name max_size:40 # CHRE_AUDIO_SOURCE_NAME_MAX_SIZE
+chre.rpc.ChreAudioDataEvent.samples max_size:64000
+chre.rpc.ChreAudioDataSamples.samples max_size:200
+chre.rpc.ChreBleGenericFilter.data max_size:29 # CHRE_BLE_DATA_LEN_MAX
+chre.rpc.ChreBleGenericFilter.mask max_size:29 # CHRE_BLE_DATA_LEN_MAX
+chre.rpc.ChreGetHostEndpointInfoOutput.endpointName max_size:51 # CHRE_MAX_ENDPOINT_NAME_LEN
+chre.rpc.ChreGetHostEndpointInfoOutput.endpointTag max_size:51 # CHRE_MAX_ENDPOINT_TAG_LEN
+chre.rpc.GatherEventsInput.eventTypes max_count:10
+chre.rpc.ChreBleAdvertisingReport.address max_size:6 # CHRE_BLE_ADDRESS_LEN
+chre.rpc.ChreBleAdvertisingReport.directAddress max_size:6 # CHRE_BLE_ADDRESS_LEN
+chre.rpc.ChreBleAdvertisingReport.data max_size:255 # extended range is [0, 255]
diff --git a/apps/test/common/chre_cross_validator_wifi/Makefile b/apps/test/common/chre_cross_validator_wifi/Makefile
index 862f248..e3f53f0 100644
--- a/apps/test/common/chre_cross_validator_wifi/Makefile
+++ b/apps/test/common/chre_cross_validator_wifi/Makefile
@@ -44,7 +44,7 @@
# Compiler Flags ###############################################################
# Defines
-COMMON_CFLAGS += -DNANOAPP_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_INFO
+COMMON_CFLAGS += -DNANOAPP_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG
COMMON_CFLAGS += -DLOG_TAG=\"[ChreCrossValidatorWifi]\"
COMMON_CFLAGS += -DCHRE_ASSERTIONS_ENABLED
diff --git a/apps/test/common/chre_cross_validator_wifi/inc/chre_cross_validator_wifi_manager.h b/apps/test/common/chre_cross_validator_wifi/inc/chre_cross_validator_wifi_manager.h
index 0a7abc2..b8db737 100644
--- a/apps/test/common/chre_cross_validator_wifi/inc/chre_cross_validator_wifi_manager.h
+++ b/apps/test/common/chre_cross_validator_wifi/inc/chre_cross_validator_wifi_manager.h
@@ -32,9 +32,7 @@
#include "chre_test_common.nanopb.h"
#include "wifi_scan_result.h"
-namespace chre {
-
-namespace cross_validator_wifi {
+namespace chre::cross_validator_wifi {
/**
* Class to manage a CHRE cross validator wifi nanoapp.
@@ -69,6 +67,10 @@
// CHRE to receive more result.
uint8_t mExpectedMaxChreResultCanHandle = 100;
+ // Bool for tracking if we have seen the start of a scan result series. Used
+ // to avoid catching the tail end of a previous scan result.
+ bool mScanStartSeen = false;
+
//! Bools indicating that data collection is complete for each side
bool mApDataCollectionDone = false;
bool mChreDataCollectionDone = false;
@@ -90,22 +92,21 @@
chre_cross_validation_wifi_StepStartCommand stepStartCommand);
/**
+ * Sends the test result to host.
+ *
* @param success true if the result was success.
* @param errMessage The error message that should be sent to host with
* failure.
- *
- * @return The TestResult proto message that is encoded with these fields.
*/
- chre_test_common_TestResult makeTestResultProtoMessage(
- bool success, const char *errMessage = nullptr);
+ void sendTestResult(bool success, const char *errorMessage = nullptr) const;
/**
* @param capabilitiesFromChre The number with flags that represent the
* different wifi capabilities.
* @return The wifi capabilities proto message for the host.
*/
- chre_cross_validation_wifi_WifiCapabilities makeWifiCapabilitiesMessage(
- uint32_t capabilitiesFromChre);
+ static chre_cross_validation_wifi_WifiCapabilities
+ makeWifiCapabilitiesMessage(uint32_t capabilitiesFromChre);
/**
* Handle a wifi scan result data message sent from AP.
@@ -144,43 +145,21 @@
* @return The index of the matched scan result in the list if
* found, otherwise SIZE_MAX.
*/
- size_t getMatchingScanResultIndex(
+ static size_t getMatchingScanResultIndex(
const DynamicVector<WifiScanResult> &results,
const WifiScanResult &queryResult);
/**
- * Setup WiFi scan monitoring from CHRE apis.
- *
- * @return true if chreWifiConfigureScanMonitorAsync() returns true
- */
- bool setupWifiScanMonitoring();
-
- /**
* Handle wifi async result event with event data.
*
* @param result The data for the event.
*/
void handleWifiAsyncResult(const chreAsyncResult *result);
-
- /**
- * The function to pass as the encode function pointer for the errorMessage
- * field of the TestResult message.
- *
- * @param stream The stream to write bytes to.
- * @param field The field that should be encoded. Unused by us.
- * @param arg The argument that will be set to a pointer to the string to
- * encode as error message.
- */
- static bool encodeErrorMessage(pb_ostream_t *stream,
- const pb_field_t * /*field*/,
- void *const *arg);
};
// The chre cross validator manager singleton.
typedef chre::Singleton<Manager> ManagerSingleton;
-} // namespace cross_validator_wifi
-
-} // namespace chre
+} // namespace chre::cross_validator_wifi
#endif // CHRE_CROSS_VALIDATOR_WIFI_MANAGER_H_
diff --git a/apps/test/common/chre_cross_validator_wifi/src/chre_cross_validator_wifi_manager.cc b/apps/test/common/chre_cross_validator_wifi/src/chre_cross_validator_wifi_manager.cc
index 4bd78ce..a210237 100644
--- a/apps/test/common/chre_cross_validator_wifi/src/chre_cross_validator_wifi_manager.cc
+++ b/apps/test/common/chre_cross_validator_wifi/src/chre_cross_validator_wifi_manager.cc
@@ -15,25 +15,15 @@
#include "chre_cross_validator_wifi_manager.h"
-#include <stdio.h>
-#include <algorithm>
#include <cinttypes>
#include <cstring>
-#include "chre/util/nanoapp/assert.h"
-#include "chre/util/nanoapp/callbacks.h"
#include "chre/util/nanoapp/log.h"
#include "chre/util/nanoapp/wifi.h"
#include "chre_api/chre.h"
-#include "chre_cross_validation_wifi.nanopb.h"
-#include "chre_test_common.nanopb.h"
#include "send_message.h"
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-
-namespace chre {
-
-namespace cross_validator_wifi {
+namespace chre::cross_validator_wifi {
// Fake scan monitor cookie which is not used
constexpr uint32_t kScanMonitoringCookie = 0;
@@ -62,31 +52,31 @@
const chreMessageFromHostData *hostData) {
if (senderInstanceId != CHRE_INSTANCE_ID) {
LOGE("Incorrect sender instance id: %" PRIu32, senderInstanceId);
- } else {
- mCrossValidatorState.hostEndpoint = hostData->hostEndpoint;
- switch (hostData->messageType) {
- case chre_cross_validation_wifi_MessageType_STEP_START: {
- pb_istream_t stream = pb_istream_from_buffer(
- static_cast<const pb_byte_t *>(
- const_cast<const void *>(hostData->message)),
- hostData->messageSize);
- chre_cross_validation_wifi_StepStartCommand stepStartCommand;
- if (!pb_decode(&stream,
- chre_cross_validation_wifi_StepStartCommand_fields,
- &stepStartCommand)) {
- LOGE("Error decoding StepStartCommand");
- } else {
- handleStepStartMessage(stepStartCommand);
- }
+ return;
+ }
+ mCrossValidatorState.hostEndpoint = hostData->hostEndpoint;
+ switch (hostData->messageType) {
+ case chre_cross_validation_wifi_MessageType_STEP_START: {
+ pb_istream_t stream = pb_istream_from_buffer(
+ static_cast<const pb_byte_t *>(
+ const_cast<const void *>(hostData->message)),
+ hostData->messageSize);
+ chre_cross_validation_wifi_StepStartCommand stepStartCommand;
+ if (!pb_decode(&stream,
+ chre_cross_validation_wifi_StepStartCommand_fields,
+ &stepStartCommand)) {
+ LOGE("Error decoding StepStartCommand");
break;
}
- case chre_cross_validation_wifi_MessageType_SCAN_RESULT:
- handleDataMessage(hostData);
- break;
- default:
- LOGE("Unknown message type %" PRIu32 " for host message",
- hostData->messageType);
+ handleStepStartMessage(stepStartCommand);
+ break;
}
+ case chre_cross_validation_wifi_MessageType_SCAN_RESULT:
+ handleDataMessage(hostData);
+ break;
+ default:
+ LOGE("Unknown message type %" PRIu32 " for host message",
+ hostData->messageType);
}
}
@@ -97,6 +87,7 @@
LOGE("Received StepStartCommand for INIT step");
break;
case chre_cross_validation_wifi_Step_CAPABILITIES: {
+ LOGD("%s: Received Step_CAPABILITIES", __func__);
chre_cross_validation_wifi_WifiCapabilities wifiCapabilities =
makeWifiCapabilitiesMessage(chreWifiGetCapabilities());
test_shared::sendMessageToHost(
@@ -106,24 +97,28 @@
break;
}
case chre_cross_validation_wifi_Step_SETUP: {
- if (!chreWifiConfigureScanMonitorAsync(true /* enable */,
+ if (!chreWifiConfigureScanMonitorAsync(/* enable= */ true,
&kScanMonitoringCookie)) {
LOGE("chreWifiConfigureScanMonitorAsync() failed");
test_shared::sendTestResultWithMsgToHost(
mCrossValidatorState.hostEndpoint,
chre_cross_validation_wifi_MessageType_STEP_RESULT,
- false /*success*/, "setupWifiScanMonitoring failed",
- false /*abortOnFailure*/);
- } else {
- LOGD("chreWifiConfigureScanMonitorAsync() succeeded");
- if (stepStartCommand.has_chreScanCapacity) {
- mExpectedMaxChreResultCanHandle = stepStartCommand.chreScanCapacity;
- }
+ /*success=*/false,
+ /* errMessage= */ "setupWifiScanMonitoring failed",
+ /*abortOnFailure=*/false);
+ break;
+ }
+ LOGD("chreWifiConfigureScanMonitorAsync() succeeded");
+ if (stepStartCommand.has_chreScanCapacity) {
+ mExpectedMaxChreResultCanHandle = stepStartCommand.chreScanCapacity;
}
break;
}
case chre_cross_validation_wifi_Step_VALIDATE:
break;
+ default:
+ LOGE("Unexpected start step: %" PRIu8,
+ static_cast<uint8_t>(stepStartCommand.step));
}
mStep = stepStartCommand.step;
}
@@ -137,28 +132,40 @@
uint8_t scanResultIndex = scanResult.getResultIndex();
if (scanResultIndex > scanResult.getTotalNumResults()) {
LOGE("AP scan result index is greater than scan results size");
- } else {
- if (!mApScanResults.push_back(scanResult)) {
- LOG_OOM();
- }
- if (scanResult.isLastMessage()) {
- mApDataCollectionDone = true;
- if (mChreDataCollectionDone) {
- compareAndSendResultToHost();
- }
- }
+ return;
+ }
+ if (!mApScanResults.push_back(scanResult)) {
+ LOG_OOM();
+ }
+ LOGD("%s: AP wifi result %" PRIu8 "/%" PRIu8 " is received", __func__,
+ static_cast<uint8_t>(scanResultIndex + 1),
+ scanResult.getTotalNumResults());
+ if (!scanResult.isLastMessage()) {
+ return;
+ }
+ mApDataCollectionDone = true;
+ if (mChreDataCollectionDone) {
+ compareAndSendResultToHost();
}
}
void Manager::handleWifiScanResult(const chreWifiScanEvent *event) {
+ if (!mScanStartSeen && event->eventIndex != 0) {
+ LOGW("Dropping chreWifiScanEvent because we haven't seen eventIndex=0");
+ return;
+ }
+ mScanStartSeen = true;
for (uint8_t i = 0; i < event->resultCount; i++) {
mChreScanResults.push_back(event->results[i]);
}
- if (mChreScanResults.size() >= event->resultTotal) {
- mChreDataCollectionDone = true;
- if (mApDataCollectionDone) {
- compareAndSendResultToHost();
- }
+ LOGD("%s: CHRE wifi result %zu/%" PRIu8 " is received", __func__,
+ mChreScanResults.size(), event->resultTotal);
+ if (mChreScanResults.size() < event->resultTotal) {
+ return;
+ }
+ mChreDataCollectionDone = true;
+ if (mApDataCollectionDone) {
+ compareAndSendResultToHost();
}
}
@@ -178,17 +185,12 @@
verifyScanResults(&testResult);
if (belowMaxSizeCheck || aboveMaxSizeCheck) {
- LOGE(
- "AP and CHRE wifi scan result counts differ, AP = %zu, CHRE = %zu, MAX "
- "= %" PRIu8,
- mApScanResults.size(), mChreScanResults.size(),
- mExpectedMaxChreResultCanHandle);
- test_shared::sendTestResultWithMsgToHost(
- mCrossValidatorState.hostEndpoint,
- chre_cross_validation_wifi_MessageType_STEP_RESULT, false /*success*/,
- "There is a different number of AP and CHRE scan results.",
- false /*abortOnFailure*/);
-
+ LOGE("Scan results differ: AP = %zu, CHRE = %zu, MAX = %" PRIu8,
+ mApScanResults.size(), mChreScanResults.size(),
+ mExpectedMaxChreResultCanHandle);
+ sendTestResult(/*success=*/false,
+ /* errorMessage= */
+ "There is a different number of AP and CHRE scan results.");
return;
}
@@ -200,32 +202,32 @@
void Manager::verifyScanResults(chre_test_common_TestResult *testResultOut) {
bool allResultsValid = true;
- for (uint8_t i = 0; i < mChreScanResults.size(); i++) {
- const WifiScanResult chreScanResult = WifiScanResult(mChreScanResults[i]);
+ for (const chreWifiScanResult &result : mChreScanResults) {
+ const WifiScanResult chreWifiScanResult = WifiScanResult(result);
bool isValidResult = true;
- size_t index = getMatchingScanResultIndex(mApScanResults, chreScanResult);
+ size_t index =
+ getMatchingScanResultIndex(mApScanResults, chreWifiScanResult);
const char *bssidStr = "<non-printable>";
char bssidBuffer[chre::kBssidStrLen];
- if (chre::parseBssidToStr(chreScanResult.getBssid(), bssidBuffer,
+ if (chre::parseBssidToStr(chreWifiScanResult.getBssid(), bssidBuffer,
sizeof(bssidBuffer))) {
bssidStr = bssidBuffer;
}
+ // chreWifiScanResult is found
if (index != SIZE_MAX) {
WifiScanResult &apScanResult = mApScanResults[index];
if (apScanResult.getSeen()) {
- *testResultOut = makeTestResultProtoMessage(
- false, "Saw a CHRE scan result with a duplicate BSSID.");
+ *testResultOut = test_shared::makeTestResultProtoMessage(
+ /*success=*/false, "Saw a CHRE scan result with a duplicate BSSID");
isValidResult = false;
- LOGE("CHRE Scan Result with bssid: %s has a dupplicate BSSID",
- bssidStr);
+ LOGE("CHRE Scan Result with bssid: %s has a duplicate BSSID", bssidStr);
}
- if (!WifiScanResult::areEqual(chreScanResult, apScanResult)) {
- *testResultOut =
- makeTestResultProtoMessage(false,
- "Fields differ between an AP and "
- "CHRE scan result with same Bssid.");
+ if (!WifiScanResult::areEqual(chreWifiScanResult, apScanResult)) {
+ *testResultOut = test_shared::makeTestResultProtoMessage(
+ /*success=*/false,
+ "Fields differ between an AP and CHRE scan result with same Bssid");
isValidResult = false;
LOGE(
"CHRE Scan Result with bssid: %s found fields differ with "
@@ -237,9 +239,9 @@
apScanResult.didSee();
} else {
// Error CHRE BSSID does not match any AP
- *testResultOut = makeTestResultProtoMessage(
- false,
- "Could not find an AP scan result with the same Bssid as a CHRE "
+ *testResultOut = test_shared::makeTestResultProtoMessage(
+ /*success=*/false,
+ "Could not find an AP scan result with the same Bssid in CHRE "
"result");
isValidResult = false;
LOGE(
@@ -247,14 +249,15 @@
"with same Bssid",
bssidStr);
}
+
if (!isValidResult) {
LOGE("False CHRE Scan Result with the following info:");
- logChreWifiResult(mChreScanResults[i]);
+ logChreWifiResult(result);
allResultsValid = false;
}
}
- for (auto &scanResult : mApScanResults) {
+ for (const WifiScanResult &scanResult : mApScanResults) {
if (!scanResult.getSeen()) {
const char *bssidStr = "<non-printable>";
char bssidBuffer[chre::kBssidStrLen];
@@ -267,16 +270,17 @@
// Since CHRE is more constrained in memory, it is expected that if we
// receive over a cretin amount of AP, we will drop some of them.
if (mApScanResults.size() <= mExpectedMaxChreResultCanHandle) {
- *testResultOut = makeTestResultProtoMessage(
- false /*success*/,
+ *testResultOut = test_shared::makeTestResultProtoMessage(
+ /*success=*/false,
"Extra AP information shown in host "
"when small number of AP results presenting");
allResultsValid = false;
}
}
}
+
if (allResultsValid) {
- *testResultOut = makeTestResultProtoMessage(true);
+ *testResultOut = test_shared::makeTestResultProtoMessage(true);
}
}
@@ -291,32 +295,11 @@
return SIZE_MAX;
}
-bool Manager::encodeErrorMessage(pb_ostream_t *stream,
- const pb_field_t * /*field*/,
- void *const *arg) {
- const char *str = static_cast<const char *>(const_cast<const void *>(*arg));
- size_t len = strlen(str);
- return pb_encode_tag_for_field(
- stream, &chre_test_common_TestResult_fields
- [chre_test_common_TestResult_errorMessage_tag - 1]) &&
- pb_encode_string(stream, reinterpret_cast<const pb_byte_t *>(str),
- len);
-}
-
-chre_test_common_TestResult Manager::makeTestResultProtoMessage(
- bool success, const char *errMessage) {
- // TODO(b/154271547): Move this implementation into
- // common/shared/send_message.cc::sendTestResultToHost
- chre_test_common_TestResult testResult =
- chre_test_common_TestResult_init_default;
- testResult.has_code = true;
- testResult.code = success ? chre_test_common_TestResult_Code_PASSED
- : chre_test_common_TestResult_Code_FAILED;
- if (!success && errMessage != nullptr) {
- testResult.errorMessage = {.funcs = {.encode = encodeErrorMessage},
- .arg = const_cast<char *>(errMessage)};
- }
- return testResult;
+void Manager::sendTestResult(bool success, const char *errorMessage) const {
+ test_shared::sendTestResultWithMsgToHost(
+ mCrossValidatorState.hostEndpoint,
+ chre_cross_validation_wifi_MessageType_STEP_RESULT, success, errorMessage,
+ /* abortOnFailure= */ false);
}
chre_cross_validation_wifi_WifiCapabilities
@@ -328,40 +311,26 @@
}
void Manager::handleWifiAsyncResult(const chreAsyncResult *result) {
- chre_test_common_TestResult testResult;
- bool sendMessage = false;
- if (result->requestType == CHRE_WIFI_REQUEST_TYPE_CONFIGURE_SCAN_MONITOR) {
- if (mStep != chre_cross_validation_wifi_Step_SETUP) {
- testResult = makeTestResultProtoMessage(
- false, "Received scan monitor result event when step is not SETUP");
- sendMessage = true;
- } else {
- if (result->success) {
- LOGD("Wifi scan monitoring setup successfully");
- testResult = makeTestResultProtoMessage(true);
- sendMessage = true;
- } else {
- LOGE("Wifi scan monitoring setup failed async w/ error code %" PRIu8
- ".",
- result->errorCode);
- testResult = makeTestResultProtoMessage(
- false, "Wifi scan monitoring setup failed async.");
- sendMessage = true;
- }
- }
- } else {
- testResult = makeTestResultProtoMessage(
- false, "Unknown chre async result type received");
- sendMessage = true;
+ if (result->requestType != CHRE_WIFI_REQUEST_TYPE_CONFIGURE_SCAN_MONITOR) {
+ sendTestResult(/*success=*/false,
+ /*errorMessage=*/"Unknown chre async result type received");
+ return;
}
- if (sendMessage) {
- test_shared::sendMessageToHost(
- mCrossValidatorState.hostEndpoint, &testResult,
- chre_test_common_TestResult_fields,
- chre_cross_validation_wifi_MessageType_STEP_RESULT);
+ if (mStep != chre_cross_validation_wifi_Step_SETUP) {
+ sendTestResult(
+ /*success=*/false,
+ /*errorMessage=*/"Received scan monitor result but step is not SETUP");
+ return;
+ }
+ if (result->success) {
+ LOGI("Wifi scan monitoring setup successfully");
+ sendTestResult(/*success=*/true);
+ } else {
+ LOGE("Wifi scan monitoring setup failed async w/ error code %" PRIu8,
+ result->errorCode);
+ sendTestResult(/*success=*/false,
+ /*errorMessage=*/"Wifi scan monitoring setup failed async");
}
}
-} // namespace cross_validator_wifi
-
-} // namespace chre
+} // namespace chre::cross_validator_wifi
diff --git a/apps/test/common/chre_settings_test/src/chre_settings_test_manager.cc b/apps/test/common/chre_settings_test/src/chre_settings_test_manager.cc
index 85502cc..8ffb6ee 100644
--- a/apps/test/common/chre_settings_test/src/chre_settings_test_manager.cc
+++ b/apps/test/common/chre_settings_test/src/chre_settings_test_manager.cc
@@ -431,7 +431,7 @@
// Retry on CHRE_ERROR_BUSY after a short delay
mWifiRequestRetries++;
- uint64_t delay = kOneSecondInNanoseconds;
+ uint64_t delay = kOneSecondInNanoseconds * 2;
gRangingRequestRetryTimerHandle = chreTimerSet(
delay, &kRangingRequestRetryTimerCookie, /*oneShot=*/true);
LOGW(
diff --git a/apps/test/common/shared/inc/send_message.h b/apps/test/common/shared/inc/send_message.h
index d79387d..cd41e34 100644
--- a/apps/test/common/shared/inc/send_message.h
+++ b/apps/test/common/shared/inc/send_message.h
@@ -20,10 +20,16 @@
#include <pb_encode.h>
#include <cinttypes>
+#include "chre/util/system/napp_permissions.h"
+#include "chre_test_common.nanopb.h"
+
namespace chre {
namespace test_shared {
+chre_test_common_TestResult makeTestResultProtoMessage(
+ bool success, const char *errMessage = nullptr);
+
/**
* Same as sendTestResultWithMsgToHost, but doesn't accept an error message and
* uses the free callback specified in chre/util/nanoapp/callbacks.h
@@ -55,7 +61,7 @@
void sendEmptyMessageToHost(uint16_t hostEndpointId, uint32_t messageType);
/**
- * Sends a message to the host.
+ * Sends a message to the host with default NanoappPermissions (CHRE_PERMS_NONE)
*
* @param hostEndpointId The endpoint Id of the host to send the message to.
* @param message The proto message struct pointer.
@@ -65,6 +71,21 @@
void sendMessageToHost(uint16_t hostEndpointId, const void *message,
const pb_field_t *fields, uint32_t messageType);
+/**
+ * Sends a message to the host with the provided NanoappPermissions.
+ *
+ * @param hostEndpointId The endpoint Id of the host to send the message to.
+ * @param message The proto message struct pointer.
+ * @param fields The fields descriptor of the proto message to encode.
+ * @param messageType The message type of the message.
+ @param perms The NanoappPermissions associated with the message.
+ */
+void sendMessageToHostWithPermissions(uint16_t hostEndpointId,
+ const void *message,
+ const pb_field_t *fields,
+ uint32_t messageType,
+ chre::NanoappPermissions perms);
+
} // namespace test_shared
} // namespace chre
diff --git a/apps/test/common/shared/src/send_message.cc b/apps/test/common/shared/src/send_message.cc
index 9f600fc..949f7fd 100644
--- a/apps/test/common/shared/src/send_message.cc
+++ b/apps/test/common/shared/src/send_message.cc
@@ -17,19 +17,17 @@
#include "send_message.h"
#include <pb_encode.h>
-#include <cinttypes>
#include "chre/util/nanoapp/callbacks.h"
#include "chre/util/nanoapp/log.h"
+#include "chre/util/system/napp_permissions.h"
#include "chre_api/chre.h"
-#include "chre_test_common.nanopb.h"
#ifndef LOG_TAG
#define LOG_TAG "[TestShared]"
#endif
-namespace chre {
-namespace test_shared {
+namespace chre::test_shared {
namespace {
bool encodeErrorMessage(pb_ostream_t *stream, const pb_field_t * /*field*/,
@@ -45,6 +43,21 @@
} // namespace
+chre_test_common_TestResult makeTestResultProtoMessage(bool success,
+ const char *errMessage) {
+ chre_test_common_TestResult testResult =
+ chre_test_common_TestResult_init_default;
+ testResult.has_code = true;
+ testResult.code = success ? chre_test_common_TestResult_Code_PASSED
+ : chre_test_common_TestResult_Code_FAILED;
+ if (!success && errMessage != nullptr) {
+ testResult.errorMessage = {.funcs = {.encode = encodeErrorMessage},
+ .arg = const_cast<char *>(errMessage)};
+ LOGE("%s", errMessage);
+ }
+ return testResult;
+}
+
void sendTestResultWithMsgToHost(uint16_t hostEndpointId, uint32_t messageType,
bool success, const char *errMessage,
bool abortOnFailure) {
@@ -55,15 +68,8 @@
success = false;
}
- chre_test_common_TestResult result = chre_test_common_TestResult_init_default;
- result.has_code = true;
- result.code = success ? chre_test_common_TestResult_Code_PASSED
- : chre_test_common_TestResult_Code_FAILED;
- if (!success && errMessage != nullptr) {
- result.errorMessage = {.funcs = {.encode = encodeErrorMessage},
- .arg = const_cast<char *>(errMessage)};
- LOGE("%s", errMessage);
- }
+ chre_test_common_TestResult result =
+ makeTestResultProtoMessage(success, errMessage);
sendMessageToHost(hostEndpointId, &result, chre_test_common_TestResult_fields,
messageType);
@@ -95,6 +101,15 @@
void sendMessageToHost(uint16_t hostEndpointId, const void *message,
const pb_field_t *fields, uint32_t messageType) {
+ sendMessageToHostWithPermissions(hostEndpointId, message, fields, messageType,
+ chre::NanoappPermissions::CHRE_PERMS_NONE);
+}
+
+void sendMessageToHostWithPermissions(uint16_t hostEndpointId,
+ const void *message,
+ const pb_field_t *fields,
+ uint32_t messageType,
+ chre::NanoappPermissions perms) {
size_t size;
if (!pb_get_encoded_size(&size, fields, message)) {
LOGE("Failed to get message size");
@@ -107,15 +122,13 @@
if (!pb_encode(&stream, fields, message)) {
LOGE("Failed to encode message error %s", PB_GET_ERROR(&stream));
chreHeapFree(bytes);
- } else if (!chreSendMessageToHostEndpoint(bytes, size, messageType,
- hostEndpointId,
- heapFreeMessageCallback)) {
+ } else if (!chreSendMessageWithPermissions(
+ bytes, size, messageType, hostEndpointId,
+ static_cast<uint32_t>(perms), heapFreeMessageCallback)) {
LOGE("Failed to send message to host");
}
}
}
}
-} // namespace test_shared
-
-} // namespace chre
+} // namespace chre::test_shared
diff --git a/apps/wifi_world/wifi_world.cc b/apps/wifi_world/wifi_world.cc
index b0f2eb0..92767c6 100644
--- a/apps/wifi_world/wifi_world.cc
+++ b/apps/wifi_world/wifi_world.cc
@@ -208,8 +208,6 @@
if (result->cookie != &kOnDemandScanCookie) {
LOGE("On-demand scan cookie mismatch");
}
-
- requestDelayedWifiScan();
} else if (result->requestType == CHRE_WIFI_REQUEST_TYPE_RANGING) {
uint64_t timeSinceRequest = chreGetTime() - gLastRangingTimeNs;
if (result->success) {
@@ -277,9 +275,10 @@
* @param event a pointer to the details of the WiFi scan event.
*/
void handleWifiScanEvent(const chreWifiScanEvent *event) {
- LOGI("Received Wifi scan event of type %" PRIu8 " with %" PRIu8
- " results at %" PRIu64 "ns",
- event->scanType, event->resultCount, event->referenceTime);
+ LOGI("Received Wifi scan event of type %" PRIu8 " index %" PRIu8
+ " with %" PRIu8 "/%" PRIu8 " results completed at %" PRIu64 "ns",
+ event->scanType, event->eventIndex, event->resultCount,
+ event->resultTotal, event->referenceTime);
if (gPendingOnDemandScan) {
uint64_t timeSinceRequest = chreGetTime() - gLastRequestTimeNs;
@@ -349,6 +348,8 @@
} else {
LOGE("Received invalid timer handle");
}
+
+ requestDelayedWifiScan();
}
} // namespace
diff --git a/build/common.mk b/build/common.mk
index 8de6ed4..7a3a490 100644
--- a/build/common.mk
+++ b/build/common.mk
@@ -47,8 +47,8 @@
include $(CHRE_PREFIX)/build/clean.mk
include $(CHRE_PREFIX)/build/tools_config.mk
-# Flag config
-include $(CHRE_PREFIX)/build/embedded_flags.mk
+# Flag config (currently disabled)
+# include $(CHRE_PREFIX)/build/embedded_flags.mk
# NanoPB Source Generation
include $(CHRE_PREFIX)/build/nanopb.mk
diff --git a/build/nanopb.mk b/build/nanopb.mk
index 75d77af..57a287e 100644
--- a/build/nanopb.mk
+++ b/build/nanopb.mk
@@ -204,13 +204,15 @@
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--out-dir=$(PW_RPC_GEN_PATH)/py/pw_rpc/internal \
--compile-dir=$(dir $<) --sources $(PW_RPC_GENERATOR_PROTO) \
- --language python
+ --language python \
+ --no-experimental-editions
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) \
--plugin-path=$(PIGWEED_DIR)/pw_protobuf/py/pw_protobuf/plugin.py \
--compile-dir=$(dir $<) --sources $(PW_RPC_GENERATOR_PROTO) \
- --language pwpb
+ --language pwpb \
+ --no-experimental-editions
# Generated PW RPC Files #######################################################
@@ -266,7 +268,7 @@
# Pigweed RPC sources
COMMON_SRCS += $(PIGWEED_DIR)/pw_assert_log/assert_log.cc
-COMMON_SRCS += $(PIGWEED_DIR)/pw_containers/intrusive_list.cc
+COMMON_SRCS += $(PIGWEED_DIR)/pw_containers/intrusive_item.cc
COMMON_SRCS += $(PIGWEED_DIR)/pw_protobuf/decoder.cc
COMMON_SRCS += $(PIGWEED_DIR)/pw_protobuf/encoder.cc
COMMON_SRCS += $(PIGWEED_DIR)/pw_protobuf/stream_decoder.cc
@@ -326,26 +328,31 @@
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(NANOPB_PROTOC) \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language nanopb \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_protobuf/py/pw_protobuf/plugin.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language pwpb \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_nanopb.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language nanopb_rpc \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_raw.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language raw_rpc \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_pwpb.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language pwpb_rpc \
+ --no-experimental-editions \
--sources $<
$(PW_RPC_GEN_PATH)/%.pb.c \
@@ -359,26 +366,31 @@
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(NANOPB_PROTOC) \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language nanopb \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_protobuf/py/pw_protobuf/plugin.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language pwpb \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_nanopb.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language nanopb_rpc \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_raw.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language raw_rpc \
+ --no-experimental-editions \
--sources $<
$(V)$(PW_RPC_GENERATOR_CMD) $(PW_RPC_PROTO_GENERATOR) \
--plugin-path=$(PIGWEED_DIR)/pw_rpc/py/pw_rpc/plugin_pwpb.py \
--out-dir=$(PW_RPC_GEN_PATH)/$(dir $<) --compile-dir=$(dir $<) --language pwpb_rpc \
+ --no-experimental-editions \
--sources $<
endif # ifneq ($(PW_RPC_SRCS),)
diff --git a/build/sys_support/qcom/chre.scons b/build/sys_support/qcom/chre.scons
deleted file mode 100644
index f911d59..0000000
--- a/build/sys_support/qcom/chre.scons
+++ /dev/null
@@ -1,382 +0,0 @@
-# Copyright (C) 2019 The Android Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-#===============================================================================
-#
-# CHRE builder scons
-#
-# GENERAL DESCRIPTION
-# Build script used to build the CHRE library for use on SLPI
-#
-#-------------------------------------------------------------------------------
-
-Import('env')
-import os
-
-#-------------------------------------------------------------------------------
-# Configure optional features
-#-------------------------------------------------------------------------------
-
-# There are two options to configure the optional features that CHRE bundles in:
-# 1. Set the flags below to True/False depending on which features are desired
-# 2. Set the command-line flag -f USES_CHRE_BUILD_FLAGS to ignore the defaults
-# and control the features by presence of -f USES_CHRE_WIFI, etc. in the
-# command line flags
-USE_CHRE_AUDIO = False # not currently supported
-if 'USES_CHRE_BUILD_FLAGS' not in env:
- # Option 1
- USE_CHRE_GNSS = True
- USE_CHRE_WIFI = True
- USE_CHRE_WWAN = True
-else:
- # Option 2
- USE_CHRE_GNSS = 'USES_CHRE_GNSS' in env
- USE_CHRE_WIFI = 'USES_CHRE_WIFI' in env
- USE_CHRE_WWAN = 'USES_CHRE_WWAN' in env
-
-#-------------------------------------------------------------------------------
-# Configure testing nanoapps
-#-------------------------------------------------------------------------------
-
-# CHRE provides several nanoapps that can be used to verify that APIs are
-# working as expected. To use these nanoapps, set 1 or more of the following
-# flags to True and recompile CHRE. Once restarted, CHRE will load the enabled
-# nanoapps
-LOAD_GNSS_WORLD = False
-LOAD_SENSOR_WORLD = False
-LOAD_WIFI_WORLD = False
-LOAD_WWAN_WORLD = False
-
-TESTING_NANOAPPS_ENABLED = False
-if LOAD_GNSS_WORLD or LOAD_SENSOR_WORLD or LOAD_WIFI_WORLD or LOAD_WWAN_WORLD:
- TESTING_NANOAPPS_ENABLED = True
-
-#-------------------------------------------------------------------------------
-# Setup source and tooling paths
-#-------------------------------------------------------------------------------
-SRCPATH = "${BUILD_ROOT}/chre/chre/src"
-LIBNAME = 'libchre_slpi_skel'
-env.VariantDir('${BUILDPATH}', SRCPATH, duplicate=0)
-LIB_ROOT = "${BUILD_ROOT}/chre/chre"
-
-target_so = '${BUILDPATH}/'+LIBNAME+'.so'
-hexagon_root = env.get('HEXAGON_ROOT')
-hexgaon_rtos_release = env.get('HEXAGON_RTOS_RELEASE')
-hexagon_version = env.get('Q6VERSION')
-HEXAGON_LIB_PATH = "{0}/{1}/Tools/target/hexagon/lib/{2}/G0/pic".format(hexagon_root,
- hexgaon_rtos_release,hexagon_version)
-
-#-------------------------------------------------------------------------------
-# Setup various env flags
-#-------------------------------------------------------------------------------
-env.Replace(ASM_DFLAGS = '-D__V_DYNAMIC__')
-env.Replace(CC_DFLAGS = '-D__V_DYNAMIC__')
-env.Replace(HEXAGONCC_OPT = ' -Os ')
-env.Replace(CFLAGS = ' -G0')
-
-env.Replace(HEXAGONCC_WARN = '-Wall -Wno-cast-align -Wpointer-arith -Wno-missing-braces' \
- ' -Wno-strict-aliasing -Wstrict-prototypes -Wnested-externs -Werror')
-env.Replace(HEXAGON_UNDEF = ' ')
-env.Replace(HEXAGON_LANIND = '-fno-exceptions -fno-strict-aliasing -fno-zero-initialized-in-bss' \
- ' -fdata-sections -fno-signed-char -fdiagnostics-show-option ')
-env.Append(SHCXXFLAGS = ' -std=c++11 ')
-env.Append(SHLINKFLAGS = '-G0 --wrap=malloc --wrap=calloc --wrap=free --wrap=realloc --wrap=memalign' \
- ' --wrap=__stack_chk_fail -call_shared ')
-
-env['SKEL_DEP'] = ''
-if USE_CHRE_GNSS:
- env['SKEL_DEP'] += ' ${BUILD_ROOT}/chre/chre_drv_loc/build/${BUILDPATH}/chre_drv_loc.so '
- env.Depends(target_so,'${BUILD_ROOT}/chre/chre_drv_loc/build/${BUILDPATH}/chre_drv_loc.so')
-
-if USE_CHRE_WIFI:
- env['SKEL_DEP'] += ' ${BUILD_ROOT}/chre/chre_drv_wifi/build/${BUILDPATH}/chre_drv_wifi.so ' \
- ' ${BUILD_ROOT}/chre/lowi_client/build/${BUILDPATH}/lowi_client.so '
- env.Depends(target_so,'${BUILD_ROOT}/chre/chre_drv_wifi/build/${BUILDPATH}/chre_drv_wifi.so')
- env.Depends(target_so,'${BUILD_ROOT}/chre/lowi_client/build/${BUILDPATH}/lowi_client.so')
-
-if USE_CHRE_WWAN:
- env['SKEL_DEP'] += ' ${BUILD_ROOT}/chre/chre_drv_modem/build/${BUILDPATH}/chre_drv_modem.so '
- env.Depends(target_so,'${BUILD_ROOT}/chre/chre_drv_modem/build/${BUILDPATH}/chre_drv_modem.so')
-
-env.Replace(QDSP6OBJS1= '${QDSP6_RELEASE_DIR}/Tools/target/hexagon/lib/${Q6VERSION}/G0/pic/initS.o')
-env.Replace(QDSP6OBJS3= ['${QDSP6_RELEASE_DIR}/Tools/target/hexagon/lib/${Q6VERSION}/G0/pic/libgcc.a',
- '${QDSP6_RELEASE_DIR}/Tools/target/hexagon/lib/${Q6VERSION}/G0/pic/libstdc++.a',
- '${QDSP6_RELEASE_DIR}/Tools/target/hexagon/lib/${Q6VERSION}/G0/pic/libc++.a'])
-env.Replace(QDSP6OBJS4= '${QDSP6_RELEASE_DIR}/Tools/target/hexagon/lib/${Q6VERSION}/G0/pic/finiS.o')
-
-env['SHLINKGRP'] = ' -shared -fPIC -Bsymbolic --start-group $QDSP6OBJS1 $QDSP6OBJS3 $SOURCES.posix' \
- ' $QDSP6OBJS4 $SKEL_DEP --end-group ${HEXAGONLD_MAP_CMD} ${TARGET.posix}.map'
-
-# Tells SCons to link various shared libraries against the CHRE library (drivers, various Hexagon libraries).
-env.Replace(SHLINKCOM="${TEMPFILE('$SHLINK $SHLINKFLAGS $HEXAGON_OUTPUT_CMD $TARGET.posix $SHLINKGRP')}")
-
-#-------------------------------------------------------------------------------
-# Ensure required libraries are available to the CHRE source code
-#-------------------------------------------------------------------------------
-core_public_apis = [
- 'KERNEL',
- 'SERVICES',
- 'DEBUGTOOLS',
- 'ADSPPM',
- 'POWER',
- 'MPROC',
- 'SYSTEMDRIVERS',
- 'DEBUGTRACE',
- 'DAL',
- 'DIAG',
- 'BUSES',
-]
-
-platform_public_apis = [
- 'PLATFORM_LIBS',
- 'MOD_TABLE',
- 'QAIC',
- 'STDDEF',
- 'REMOTE',
- 'HAPSDK',
- 'DLW',
- 'PLS',
- 'UTILS',
- 'ADSP_MMAP',
- 'A1STD',
- 'RTLD',
-]
-
-qmimsgs_public_apis = [
- 'COMMON',
- 'SNS_CLIENT_API',
-]
-
-chre_priv_api = [
- "${BUILD_ROOT}/chre/chre/src/system/chre/chre_api/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/chre_api/include/chre_api",
- "${BUILD_ROOT}/chre/chre/src/system/chre/core/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/external/flatbuffers/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/pal/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/platform/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/platform/shared/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/platform/slpi",
- "${BUILD_ROOT}/chre/chre/src/system/chre/platform/slpi/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/platform/slpi/see/include",
- "${BUILD_ROOT}/chre/chre/src/system/chre/util/include",
- "${BUILD_ROOT}/core/api/kernel/libstd/stringl",
- "${BUILD_ROOT}/qmimsgs/common/api",
- "${BUILD_ROOT}/ssc_api/pb",
- "${BUILD_ROOT}/ssc/framework/cm/inc",
- "${BUILD_ROOT}/ssc/inc",
- "${BUILD_ROOT}/ssc/inc/internal",
- "${BUILD_ROOT}/ssc/inc/utils/nanopb",
-]
-
-if TESTING_NANOAPPS_ENABLED:
- chre_priv_api.append("${BUILD_ROOT}/chre/chre/src/system/chre/apps/include")
-
-env.PublishPrivateApi('CHRE', chre_priv_api)
-
-env.RequirePublicApi(core_public_apis, area='core')
-env.RequirePublicApi(platform_public_apis, area='platform')
-env.RequirePublicApi(qmimsgs_public_apis, area='qmimsgs')
-env.RequirePublicApi(['SNS_API_INCLUDES'], area='ssc_api')
-env.RequirePrivateApi('CHRE')
-
-#-------------------------------------------------------------------------------
-# Define various preprocessor definitions needed to compile CHRE
-#-------------------------------------------------------------------------------
-
-oem_ver = os.environ.get('SCONS_OEM_BUILD_VER')
-if oem_ver is not None:
- oem_ver = str(oem_ver).strip().strip('"')
-else:
- oem_ver = 'undefined'
-
-CHRE_DEFINES = [
- 'CHRE_SLPI_DEFAULT_BUILD',
- 'CHRE_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG',
- 'NANOAPP_MINIMUM_LOG_LEVEL=CHRE_LOG_LEVEL_DEBUG',
- 'CHRE_ASSERTIONS_DISABLED',
- 'CHRE_NANOAPP_INTERNAL',
- 'CHRE_VERSION_STRING=\\\"' + oem_ver + '\\\"',
- 'CHRE_PATCH_VERSION=1',
- 'CHRE_FILENAME=__FILE__',
- 'CHRE_PLATFORM_ID=0x476f6f676c000005',
- 'CHRE_SEE_NUM_TEMP_SENSORS=1',
- 'FLATBUFFERS_CHRE',
- 'SSC_TARGET_HEXAGON',
- 'CHRE_SLPI_SEE',
- 'PB_FIELD_16BIT',
- 'CHRE_MESSAGE_TO_HOST_MAX_SIZE=4000',
- 'QDSP6',
- 'CHRE_USE_FARF_LOGGING',
-]
-
-if USE_CHRE_GNSS:
- CHRE_DEFINES.append('CHRE_GNSS_SUPPORT_ENABLED')
-if USE_CHRE_WIFI:
- CHRE_DEFINES.append('CHRE_WIFI_SUPPORT_ENABLED')
-if USE_CHRE_WWAN:
- CHRE_DEFINES.append('CHRE_WWAN_SUPPORT_ENABLED')
-
-if TESTING_NANOAPPS_ENABLED:
- CHRE_DEFINES.append('CHRE_INCLUDE_DEFAULT_STATIC_NANOAPPS')
-if LOAD_GNSS_WORLD:
- CHRE_DEFINES.append('CHRE_LOAD_GNSS_WORLD')
-if LOAD_SENSOR_WORLD:
- CHRE_DEFINES.append('CHRE_LOAD_SENSOR_WORLD')
-if LOAD_WIFI_WORLD:
- CHRE_DEFINES.append('CHRE_LOAD_WIFI_WORLD')
-if LOAD_WWAN_WORLD:
- CHRE_DEFINES.append('CHRE_LOAD_WWAN_WORLD')
-
-env.Append(CPPDEFINES = CHRE_DEFINES)
-
-#-------------------------------------------------------------------------------
-# Setup source files to be built
-#-------------------------------------------------------------------------------
-
-# Define path to the IDL file used to communicate with the host via FastRPC
-libchre_slpi_skel_idl = "${BUILDPATH}/system/chre/host/msm/daemon/idl/chre_slpi.idl"
-
-# Compile chre_slpi.h from chre_slpi.idl, This is a prereq for the libchre_slpi_skel.so
-prereq = env.HeaderBuilder("${BUILDPATH}/chre_slpi.h", libchre_slpi_skel_idl)
-
-chre_cc_src = [
- # QMI interfaces
- "${BUILD_ROOT}/qmimsgs/common/src/common_v01.c",
- "${BUILD_ROOT}/qmimsgs/sns_client_api/src/sns_client_api_v01.c",
-
- # Qualcomm protobufs needed by CHRE code
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_amd.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_client.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_suid.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_cal.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_physical_sensor_test.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_proximity.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_remote_proc_state.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_resampler.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_std.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_std_sensor.pb.c",
- "${BUILD_ROOT}/ssc_api/build/${BUILDPATH}/pb/sns_std_type.pb.c",
-
- # Core CHRE framework code
- "${BUILDPATH}/system/chre/core/debug_dump_manager.cc",
- "${BUILDPATH}/system/chre/core/event.cc",
- "${BUILDPATH}/system/chre/core/event_loop.cc",
- "${BUILDPATH}/system/chre/core/event_loop_manager.cc",
- "${BUILDPATH}/system/chre/core/event_ref_queue.cc",
- "${BUILDPATH}/system/chre/core/host_comms_manager.cc",
- "${BUILDPATH}/system/chre/core/init.cc",
- "${BUILDPATH}/system/chre/core/nanoapp.cc",
- "${BUILDPATH}/system/chre/core/sensor_request.cc",
- "${BUILDPATH}/system/chre/core/sensor_request_manager.cc",
- "${BUILDPATH}/system/chre/core/sensor_request_multiplexer.cc",
- "${BUILDPATH}/system/chre/core/sensor.cc",
- "${BUILDPATH}/system/chre/core/sensor_type.cc",
- "${BUILDPATH}/system/chre/core/sensor_type_helpers.cc",
- "${BUILDPATH}/system/chre/core/static_nanoapps.cc",
- "${BUILDPATH}/system/chre/core/timer_pool.cc",
-
- # CHRE platform-specific implementation
- "${BUILDPATH}/system/chre/platform/shared/chre_api_audio.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_core.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_gnss.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_re.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_sensor.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_version.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_wifi.cc",
- "${BUILDPATH}/system/chre/platform/shared/chre_api_wwan.cc",
- "${BUILDPATH}/system/chre/platform/shared/host_protocol_chre.cc",
- "${BUILDPATH}/system/chre/platform/shared/host_protocol_common.cc",
- "${BUILDPATH}/system/chre/platform/shared/memory_manager.cc",
- "${BUILDPATH}/system/chre/platform/shared/nanoapp_load_manager.cc",
- "${BUILDPATH}/system/chre/platform/shared/nanoapp/nanoapp_dso_util.cc",
- "${BUILDPATH}/system/chre/platform/shared/pal_system_api.cc",
- "${BUILDPATH}/system/chre/platform/shared/platform_debug_dump_manager.cc",
- "${BUILDPATH}/system/chre/platform/shared/system_time.cc",
- "${BUILDPATH}/system/chre/platform/slpi/chre_api_re.cc",
- "${BUILDPATH}/system/chre/platform/slpi/host_link.cc",
- "${BUILDPATH}/system/chre/platform/slpi/init.cc",
- "${BUILDPATH}/system/chre/platform/slpi/memory.cc",
- "${BUILDPATH}/system/chre/platform/slpi/memory_manager.cc",
- "${BUILDPATH}/system/chre/platform/slpi/platform_nanoapp.cc",
- "${BUILDPATH}/system/chre/platform/slpi/platform_pal.cc",
- "${BUILDPATH}/system/chre/platform/slpi/platform_sensor_type_helpers.cc",
- "${BUILDPATH}/system/chre/platform/slpi/system_time.cc",
- "${BUILDPATH}/system/chre/platform/slpi/system_time_util.cc",
- "${BUILDPATH}/system/chre/platform/slpi/system_timer.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/island_vote_client.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/platform_sensor.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/platform_sensor_manager.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/power_control_manager.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/see_helper.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/see_cal_helper.cc",
- "${BUILDPATH}/system/chre/platform/slpi/see/sns_qmi_client.c",
-
- # Common utilities
- "${BUILDPATH}/system/chre/util/system/debug_dump.cc",
- "${BUILDPATH}/system/chre/util/buffer_base.cc",
- "${BUILDPATH}/system/chre/util/dynamic_vector_base.cc",
- "${BUILDPATH}/system/chre/util/hash.cc",
- "${BUILDPATH}/system/chre/util/nanoapp/audio.cc",
- "${BUILDPATH}/system/chre/util/nanoapp/ble.cc",
- "${BUILDPATH}/system/chre/util/nanoapp/callbacks.cc",
- "${BUILDPATH}/system/chre/util/nanoapp/debug.cc",
- "${BUILDPATH}/system/chre/util/nanoapp/wifi.cc",
-]
-
-if USE_CHRE_AUDIO:
- chre_cc_src.extend([
- "${BUILDPATH}/system/chre/core/audio_request_manager.cc",
- "${BUILDPATH}/system/chre/platform/slpi/platform_audio.cc",
- ])
-
-if USE_CHRE_GNSS:
- chre_cc_src.extend([
- "${BUILDPATH}/system/chre/core/gnss_manager.cc",
- "${BUILDPATH}/system/chre/platform/shared/platform_gnss.cc",
- ])
-
-if USE_CHRE_WIFI:
- chre_cc_src.extend([
- "${BUILDPATH}/system/chre/core/wifi_request_manager.cc",
- "${BUILDPATH}/system/chre/core/wifi_scan_request.cc",
- "${BUILDPATH}/system/chre/platform/shared/platform_wifi.cc",
- ])
-
-if USE_CHRE_WWAN:
- chre_cc_src.extend([
- "${BUILDPATH}/system/chre/core/wwan_request_manager.cc",
- "${BUILDPATH}/system/chre/platform/shared/platform_wwan.cc",
- ])
-
-if LOAD_GNSS_WORLD:
- chre_cc_src.append("${BUILDPATH}/system/chre/apps/gnss_world/gnss_world.cc")
-if LOAD_SENSOR_WORLD:
- chre_cc_src.append("${BUILDPATH}/system/chre/apps/sensor_world/sensor_world.cc")
-if LOAD_WIFI_WORLD:
- chre_cc_src.append("${BUILDPATH}/system/chre/apps/wifi_world/wifi_world.cc")
-if LOAD_WWAN_WORLD:
- chre_cc_src.append("${BUILDPATH}/system/chre/apps/wwan_world/wwan_world.cc")
-
-#-------------------------------------------------------------------------------
-# Add CHRE as a shared library that should be built
-#-------------------------------------------------------------------------------
-
-target = env.AddMySharedLibrary(['ADSP_SHARED_LIBS'], '${BUILDPATH}/'+LIBNAME, chre_cc_src, libchre_slpi_skel_idl)
-env.Requires(target, prereq)
-
-# Clean / pack rules
-CLEAN_LIST=[]
-CLEAN_LIST.extend(env.FindFiles(['*'], LIB_ROOT + '/inc'))
-CLEAN_LIST.extend(env.FindFiles(['*'], LIB_ROOT + '/src'))
-env.CleanPack(['ADSP_SHARED_LIBS'], CLEAN_LIST)
diff --git a/build/variant/aosp_riscv55e03_tinysys.mk b/build/variant/aosp_riscv55e03_tinysys.mk
index 616ca54..aacd366 100644
--- a/build/variant/aosp_riscv55e03_tinysys.mk
+++ b/build/variant/aosp_riscv55e03_tinysys.mk
@@ -1,89 +1,10 @@
#
-# Google Reference CHRE Implementation for MTK riscv (v55e03) Tinysys
+# Google Reference CHRE Implementation for MTK riscv (55e03) Tinysys
#
-include $(CHRE_PREFIX)/build/clean_build_template_args.mk
+RISCV_TARGET_NAME = aosp_riscv55e03_tinysys
+RISCV_TARGET_PLATFORM_ID = 0x476f6f676c003000
+RISCV_TOOLCHAIN_TYPE = MRV55E03
+RISCV_CPU_TYPE = MRV55E03
-TARGET_NAME = aosp_riscv55e03_tinysys
-ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
-
-ifneq ($(IS_NANOAPP_BUILD),)
- # Inline functions of ctype.h for nanoapps
- COMMON_CFLAGS += -DUSE_CHARSET_ASCII
-else
- # only enforce RISCV_TINYSYS_PREFIX when building CHRE
- ifeq ($(RISCV_TINYSYS_PREFIX),)
- $(error "The tinysys code directory needs to be exported as the RISCV_TINYSYS_PREFIX \
- environment variable")
- endif
-endif
-
-TARGET_CFLAGS = $(TINYSYS_CFLAGS)
-TARGET_VARIANT_SRCS = $(TINYSYS_SRCS)
-TARGET_BIN_LDFLAGS = $(AOSP_RISCV_TINYSYS_BIN_LDFLAGS)
-TARGET_SO_EARLY_LIBS = $(AOSP_RISCV_TINYSYS_EARLY_LIBS)
-TARGET_SO_LATE_LIBS = $(AOSP_RISCV_TINYSYS_LATE_LIBS)
-TARGET_PLATFORM_ID = 0x476f6f676c003000
-
-# Macros #######################################################################
-TINYSYS_CFLAGS += $(FLATBUFFERS_CFLAGS)
-TINYSYS_CFLAGS += $(MBEDTLS_CFLAGS)
-
-TINYSYS_CFLAGS += -DCFG_DRAM_HEAP_SUPPORT
-TINYSYS_CFLAGS += -DCHRE_LOADER_ARCH=EM_RISCV
-TINYSYS_CFLAGS += -DCHRE_NANOAPP_LOAD_ALIGNMENT=4096
-
-TINYSYS_CFLAGS += -D__riscv
-TINYSYS_CFLAGS += -DMRV55
-TINYSYS_CFLAGS += -D_LIBCPP_HAS_NO_LONG_LONG
-
-TINYSYS_CFLAGS += --target=riscv32-unknown-elf
-TINYSYS_CFLAGS += -march=rv32imafcv
-TINYSYS_CFLAGS += -mcpu=MRV55E03
-
-# Word size for this architecture
-TARGET_CFLAGS += -DCHRE_32_BIT_WORD_SIZE
-
-# chre platform
-TARGET_CFLAGS += -DCHRE_FIRST_SUPPORTED_API_VERSION=CHRE_API_VERSION_1_7
-TARGET_CFLAGS += -DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4096
-TARGET_CFLAGS += -DCHRE_USE_BUFFERED_LOGGING
-# enable static allocation in freertos
-TINYSYS_CFLAGS += -DCFG_STATIC_ALLOCATE
-
-# Compiling flags ##############################################################
-
-# -fpic and -shared are only needed for dynamic linking
-ifeq ($(IS_ARCHIVE_ONLY_BUILD),)
-TARGET_SO_LDFLAGS += -shared
-TARGET_CFLAGS += -fpic
-
-# Enable compiler-rt dependencies
-LLVM_RTLIB=$(RISCV_TOOLCHAIN_PATH)/lib/clang/9.0.1/libpic/riscv32/MRV55E03
-TARGET_SO_LDFLAGS += -L$(LLVM_RTLIB)
-TARGET_SO_LDFLAGS += -lclang_rt.builtins-riscv32
-endif
-
-ifneq ($(IS_NANOAPP_BUILD),)
-# Used to expose libc headers to nanoapps that aren't supported on the given platform
-TARGET_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include/chre/platform/shared/libc
-
-TARGET_VARIANT_SRCS += $(DSO_SUPPORT_LIB_SRCS)
-TARGET_CFLAGS += $(DSO_SUPPORT_LIB_CFLAGS)
-
-ifeq ($(CHRE_TCM_ENABLED),true)
-TARGET_CFLAGS += -DCHRE_TCM_ENABLED
-# Flags:
-# Signed = 0x00000001
-# TCM-capable = 0x00000004
-TARGET_NANOAPP_FLAGS = 0x00000005
-endif
-endif
-
-# Other makefiles ##############################################################
-
-include $(CHRE_PREFIX)/platform/shared/mbedtls/mbedtls.mk
-include $(CHRE_PREFIX)/build/arch/riscv.mk
-include $(CHRE_PREFIX)/build/build_template.mk
-endif
-
+include $(CHRE_PREFIX)/build/variant/aosp_riscv_tinysys_common.mk
\ No newline at end of file
diff --git a/build/variant/aosp_riscv55e300_tinysys.mk b/build/variant/aosp_riscv55e300_tinysys.mk
index f8ffbf3..0c8c890 100644
--- a/build/variant/aosp_riscv55e300_tinysys.mk
+++ b/build/variant/aosp_riscv55e300_tinysys.mk
@@ -1,90 +1,10 @@
#
-# Google Reference CHRE Implementation for MTK riscv (v55e300) Tinysys
+# Google Reference CHRE Implementation for MTK riscv (55e300) Tinysys
#
-include $(CHRE_PREFIX)/build/clean_build_template_args.mk
+RISCV_TARGET_NAME = aosp_riscv55e300_tinysys
+RISCV_TARGET_PLATFORM_ID = 0x476f6f676c003001
+RISCV_TOOLCHAIN_TYPE = MRV55E300
+RISCV_CPU_TYPE = MRV55E300
-TARGET_NAME = aosp_riscv55e300_tinysys
-ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
-
-ifneq ($(IS_NANOAPP_BUILD),)
- # Inline functions of ctype.h for nanoapps
- COMMON_CFLAGS += -DUSE_CHARSET_ASCII
-else
- # only enforce RISCV_TINYSYS_PREFIX when building CHRE
- ifeq ($(RISCV_TINYSYS_PREFIX),)
- $(error "The tinysys code directory needs to be exported as the RISCV_TINYSYS_PREFIX \
- environment variable")
- endif
-endif
-
-TARGET_CFLAGS = $(TINYSYS_CFLAGS)
-TARGET_VARIANT_SRCS = $(TINYSYS_SRCS)
-TARGET_BIN_LDFLAGS = $(AOSP_RISCV_TINYSYS_BIN_LDFLAGS)
-TARGET_SO_EARLY_LIBS = $(AOSP_RISCV_TINYSYS_EARLY_LIBS)
-TARGET_SO_LATE_LIBS = $(AOSP_RISCV_TINYSYS_LATE_LIBS)
-TARGET_PLATFORM_ID = 0x476f6f676c003001
-
-# Macros #######################################################################
-
-TINYSYS_CFLAGS += $(FLATBUFFERS_CFLAGS)
-TINYSYS_CFLAGS += $(MBEDTLS_CFLAGS)
-
-TINYSYS_CFLAGS += -DCFG_DRAM_HEAP_SUPPORT
-TINYSYS_CFLAGS += -DCHRE_LOADER_ARCH=EM_RISCV
-TINYSYS_CFLAGS += -DCHRE_NANOAPP_LOAD_ALIGNMENT=4096
-
-TINYSYS_CFLAGS += -D__riscv
-TINYSYS_CFLAGS += -DMRV55
-TINYSYS_CFLAGS += -D_LIBCPP_HAS_NO_LONG_LONG
-
-TINYSYS_CFLAGS += --target=riscv32-unknown-elf
-TINYSYS_CFLAGS += -march=rv32imafcv
-TINYSYS_CFLAGS += -mcpu=MRV55E300
-
-# Word size for this architecture
-TARGET_CFLAGS += -DCHRE_32_BIT_WORD_SIZE
-
-# chre platform
-TARGET_CFLAGS += -DCHRE_FIRST_SUPPORTED_API_VERSION=CHRE_API_VERSION_1_7
-# TODO(b/254121302): Needs to confirm with MTK about the max message size below
-TARGET_CFLAGS += -DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4096
-TARGET_CFLAGS += -DCHRE_USE_BUFFERED_LOGGING
-# TODO(b/256870101): create mutex on heap for now
-TARGET_CFLAGS += -DCHRE_CREATE_MUTEX_ON_HEAP
-
-# Compiling flags ##############################################################
-
-# -fpic and -shared are only needed for dynamic linking
-ifeq ($(IS_ARCHIVE_ONLY_BUILD),)
-TARGET_SO_LDFLAGS += -shared
-TARGET_CFLAGS += -fpic
-
-# Enable compiler-rt dependencies
-LLVM_RTLIB=$(RISCV_TOOLCHAIN_PATH)/lib/clang/12.0.0/libpic/riscv32/MRV55E300
-TARGET_SO_LDFLAGS += -L$(LLVM_RTLIB)
-TARGET_SO_LDFLAGS += -lclang_rt.builtins-riscv32
-endif
-
-ifneq ($(IS_NANOAPP_BUILD),)
-# Used to expose libc headers to nanoapps that aren't supported on the given platform
-TARGET_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include/chre/platform/shared/libc
-
-TARGET_VARIANT_SRCS += $(DSO_SUPPORT_LIB_SRCS)
-TARGET_CFLAGS += $(DSO_SUPPORT_LIB_CFLAGS)
-
-ifeq ($(CHRE_TCM_ENABLED),true)
-TARGET_CFLAGS += -DCHRE_TCM_ENABLED
-# Flags:
-# Signed = 0x00000001
-# TCM-capable = 0x00000004
-TARGET_NANOAPP_FLAGS = 0x00000005
-endif
-endif
-
-# Other makefiles ##############################################################
-
-include $(CHRE_PREFIX)/platform/shared/mbedtls/mbedtls.mk
-include $(CHRE_PREFIX)/build/arch/riscv.mk
-include $(CHRE_PREFIX)/build/build_template.mk
-endif
+include $(CHRE_PREFIX)/build/variant/aosp_riscv_tinysys_common.mk
\ No newline at end of file
diff --git a/build/variant/aosp_riscv_tinysys_common.mk b/build/variant/aosp_riscv_tinysys_common.mk
new file mode 100644
index 0000000..136f2a4
--- /dev/null
+++ b/build/variant/aosp_riscv_tinysys_common.mk
@@ -0,0 +1,92 @@
+#
+# Google Reference CHRE Implementation for common MTK riscv Tinysys platforms.
+#
+
+# Having a clean start
+include $(CHRE_PREFIX)/build/clean_build_template_args.mk
+
+TARGET_NAME = $(RISCV_TARGET_NAME)
+TARGET_PLATFORM_ID = $(RISCV_TARGET_PLATFORM_ID)
+
+ifneq ($(filter $(TARGET_NAME)% all, $(MAKECMDGOALS)),)
+ TARGET_CFLAGS = $(TINYSYS_CFLAGS)
+ TARGET_VARIANT_SRCS = $(TINYSYS_SRCS)
+ TARGET_BIN_LDFLAGS = $(AOSP_RISCV_TINYSYS_BIN_LDFLAGS)
+ TARGET_SO_EARLY_LIBS = $(AOSP_RISCV_TINYSYS_EARLY_LIBS)
+ TARGET_SO_LATE_LIBS = $(AOSP_RISCV_TINYSYS_LATE_LIBS)
+
+ ifneq ($(IS_NANOAPP_BUILD),)
+ # Inline functions of ctype.h for nanoapps
+ COMMON_CFLAGS += -DUSE_CHARSET_ASCII
+
+ # Used to expose libc headers to nanoapps that aren't supported on the given platform
+ TARGET_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include/chre/platform/shared/libc
+
+ TARGET_VARIANT_SRCS += $(DSO_SUPPORT_LIB_SRCS)
+ TARGET_CFLAGS += $(DSO_SUPPORT_LIB_CFLAGS)
+
+ ifeq ($(CHRE_TCM_ENABLED),true)
+ TARGET_CFLAGS += -DCHRE_TCM_ENABLED
+ # Flags:
+ # Signed = 0x00000001
+ # TCM-capable = 0x00000004
+ TARGET_NANOAPP_FLAGS = 0x00000005
+ endif
+ else
+ # only enforce RISCV_TINYSYS_PREFIX when building CHRE
+ ifeq ($(RISCV_TINYSYS_PREFIX),)
+ $(error "The tinysys code directory needs to be exported as the RISCV_TINYSYS_PREFIX \
+ environment variable")
+ endif
+ endif
+
+ # Macros #######################################################################
+
+ TINYSYS_CFLAGS += -DCFG_DRAM_HEAP_SUPPORT
+ TINYSYS_CFLAGS += -DCHRE_LOADER_ARCH=EM_RISCV
+ TINYSYS_CFLAGS += -DCHRE_NANOAPP_LOAD_ALIGNMENT=4096
+
+ TINYSYS_CFLAGS += -DCFG_TASK_MULTINOTIFY_SUPPORT
+ TINYSYS_CFLAGS += -mllvm -enable-printf-opt=false
+
+ TINYSYS_CFLAGS += -D__riscv
+ TINYSYS_CFLAGS += -DMRV55
+ TINYSYS_CFLAGS += -D_LIBCPP_HAS_NO_LONG_LONG
+
+ # Word size for this architecture
+ TARGET_CFLAGS += -DCHRE_32_BIT_WORD_SIZE
+
+ # CHRE platform
+ TARGET_CFLAGS += -DCHRE_FIRST_SUPPORTED_API_VERSION=CHRE_API_VERSION_1_7
+ TARGET_CFLAGS += -DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4096
+ TARGET_CFLAGS += -DCHRE_USE_BUFFERED_LOGGING
+
+ # Enable static allocation in freertos
+ TINYSYS_CFLAGS += -DCFG_STATIC_ALLOCATE
+ TINYSYS_CFLAGS += -DconfigSUPPORT_STATIC_ALLOCATION=1
+
+ # Compiling flags ##############################################################
+
+ TINYSYS_CFLAGS += $(FLATBUFFERS_CFLAGS)
+ TINYSYS_CFLAGS += $(MBEDTLS_CFLAGS)
+ TINYSYS_CFLAGS += -mcpu=$(RISCV_CPU_TYPE)
+ TINYSYS_CFLAGS += --target=riscv32-unknown-elf
+ TINYSYS_CFLAGS += -march=rv32imafcv
+
+ # -fpic and -shared are only needed for dynamic linking
+ ifeq ($(IS_ARCHIVE_ONLY_BUILD),)
+ TARGET_SO_LDFLAGS += -shared
+ TARGET_CFLAGS += -fpic
+
+ # Enable compiler-rt dependencies
+ LLVM_RTLIB=$(RISCV_TOOLCHAIN_PATH)/lib/clang/12.0.0/libpic/riscv32/$(RISCV_TOOLCHAIN_TYPE)
+ TARGET_SO_LDFLAGS += -L$(LLVM_RTLIB)
+ TARGET_SO_LDFLAGS += -lclang_rt.builtins-riscv32
+ endif
+
+ # Other makefiles ##############################################################
+
+ include $(CHRE_PREFIX)/platform/shared/mbedtls/mbedtls.mk
+ include $(CHRE_PREFIX)/build/arch/riscv.mk
+ include $(CHRE_PREFIX)/build/build_template.mk
+endif
\ No newline at end of file
diff --git a/chpp/clients/gnss.c b/chpp/clients/gnss.c
index d084b2c..18b0e94 100644
--- a/chpp/clients/gnss.c
+++ b/chpp/clients/gnss.c
@@ -192,7 +192,8 @@
switch (rxHeader->command) {
case CHPP_GNSS_OPEN: {
chppClientProcessOpenResponse(&gnssClientContext->client, buf, len);
- if (gnssClientContext->requestStateResyncPending) {
+ if (rxHeader->error == CHPP_APP_ERROR_NONE &&
+ gnssClientContext->requestStateResyncPending) {
gCallbacks->requestStateResync();
gnssClientContext->requestStateResyncPending = false;
}
@@ -326,18 +327,13 @@
chppClientCloseOpenRequests(&gnssClientContext->client, &kGnssClientConfig,
false /* clearOnly */);
- if (gnssClientContext->client.openState != CHPP_OPEN_STATE_OPENED &&
- !gnssClientContext->client.pseudoOpen) {
- CHPP_LOGW("GNSS client reset but wasn't open");
- } else {
- CHPP_LOGD("GNSS client reopening from state=%" PRIu8,
- gnssClientContext->client.openState);
- gnssClientContext->requestStateResyncPending = true;
- chppClientSendOpenRequest(&gGnssClientContext.client,
- &gGnssClientContext.outReqStates[CHPP_GNSS_OPEN],
- CHPP_GNSS_OPEN,
- /*blocking=*/false);
- }
+ CHPP_LOGD("GNSS client reopening from state=%" PRIu8,
+ gnssClientContext->client.openState);
+ gnssClientContext->requestStateResyncPending = true;
+ chppClientSendOpenRequest(&gGnssClientContext.client,
+ &gGnssClientContext.outReqStates[CHPP_GNSS_OPEN],
+ CHPP_GNSS_OPEN,
+ /*blocking=*/false);
}
/**
diff --git a/chpp/clients/wifi.c b/chpp/clients/wifi.c
index 2f2b19b..87f28a3 100644
--- a/chpp/clients/wifi.c
+++ b/chpp/clients/wifi.c
@@ -213,7 +213,9 @@
switch (rxHeader->command) {
case CHPP_WIFI_OPEN: {
chppClientProcessOpenResponse(&wifiClientContext->client, buf, len);
- chppWiFiRecoverScanMonitor(wifiClientContext);
+ if (rxHeader->error == CHPP_APP_ERROR_NONE) {
+ chppWiFiRecoverScanMonitor(wifiClientContext);
+ }
break;
}
@@ -376,17 +378,12 @@
false /* clearOnly */);
chppCheckWifiScanEventNotificationReset();
- if (wifiClientContext->client.openState != CHPP_OPEN_STATE_OPENED &&
- !wifiClientContext->client.pseudoOpen) {
- CHPP_LOGW("WiFi client reset but wasn't open");
- } else {
- CHPP_LOGI("WiFi client reopening from state=%" PRIu8,
- wifiClientContext->client.openState);
- chppClientSendOpenRequest(&wifiClientContext->client,
- &wifiClientContext->outReqStates[CHPP_WIFI_OPEN],
- CHPP_WIFI_OPEN,
- /*blocking=*/false);
- }
+ CHPP_LOGI("WiFi client reopening from state=%" PRIu8,
+ wifiClientContext->client.openState);
+ chppClientSendOpenRequest(&wifiClientContext->client,
+ &wifiClientContext->outReqStates[CHPP_WIFI_OPEN],
+ CHPP_WIFI_OPEN,
+ /*blocking=*/false);
}
/**
@@ -491,9 +488,10 @@
if (len < sizeof(struct ChppWifiConfigureScanMonitorAsyncResponse)) {
// Short response length indicates an error
- gCallbacks->scanMonitorStatusChangeCallback(
- false, chppAppShortResponseErrorHandler(buf, len, "ScanMonitor"));
-
+ uint8_t error = chppAppShortResponseErrorHandler(buf, len, "ScanMonitor");
+ if (!gWifiClientContext.scanMonitorSilenceCallback) {
+ gCallbacks->scanMonitorStatusChangeCallback(false, error);
+ }
} else {
struct ChppWifiConfigureScanMonitorAsyncResponseParameters *result =
&((struct ChppWifiConfigureScanMonitorAsyncResponse *)buf)->params;
@@ -643,7 +641,7 @@
CHPP_WIFI_MAX_TIMESYNC_AGE_NS);
uint64_t currentTime = chppGetCurrentTimeNs();
if (correctedTime > currentTime) {
- CHPP_LOGD("WiFi scan time overcorrected %" PRIu64 " current %" PRIu64,
+ CHPP_LOGW("WiFi scan time overcorrected %" PRIu64 " current %" PRIu64,
correctedTime / CHPP_NSEC_PER_MSEC,
currentTime / CHPP_NSEC_PER_MSEC);
correctedTime = currentTime;
@@ -691,6 +689,13 @@
results[i].timestamp -
(uint64_t)chppTimesyncGetOffset(gWifiClientContext.client.appContext,
CHPP_WIFI_MAX_TIMESYNC_AGE_NS);
+ uint64_t currentTime = chppGetCurrentTimeNs();
+ if (correctedTime > currentTime) {
+ CHPP_LOGW("WiFi ranging time overcorrected %" PRIu64 " current %" PRIu64,
+ correctedTime / CHPP_NSEC_PER_MSEC,
+ currentTime / CHPP_NSEC_PER_MSEC);
+ correctedTime = currentTime;
+ }
CHPP_LOGD("WiFi ranging result time corrected from %" PRIu64 "to %" PRIu64,
results[i].timestamp / CHPP_NSEC_PER_MSEC,
correctedTime / CHPP_NSEC_PER_MSEC);
@@ -946,10 +951,7 @@
CHPP_LOG_OOM();
} else {
request->header.command = CHPP_WIFI_CONFIGURE_SCAN_MONITOR_ASYNC;
- request->params.enable = enable;
- request->params.cookie =
- &gWifiClientContext
- .outReqStates[CHPP_WIFI_CONFIGURE_SCAN_MONITOR_ASYNC];
+ request->enable = enable;
result = chppClientSendTimestampedRequestOrFail(
&gWifiClientContext.client,
diff --git a/chpp/clients/wwan.c b/chpp/clients/wwan.c
index 1ac8aa3..396a100 100644
--- a/chpp/clients/wwan.c
+++ b/chpp/clients/wwan.c
@@ -247,17 +247,12 @@
chppClientCloseOpenRequests(&wwanClientContext->client, &kWwanClientConfig,
false /* clearOnly */);
- if (wwanClientContext->client.openState != CHPP_OPEN_STATE_OPENED &&
- !wwanClientContext->client.pseudoOpen) {
- CHPP_LOGW("WWAN client reset but wasn't open");
- } else {
- CHPP_LOGI("WWAN client reopening from state=%" PRIu8,
- wwanClientContext->client.openState);
- chppClientSendOpenRequest(&wwanClientContext->client,
- &wwanClientContext->outReqStates[CHPP_WWAN_OPEN],
- CHPP_WWAN_OPEN,
- /*blocking=*/false);
- }
+ CHPP_LOGI("WWAN client reopening from state=%" PRIu8,
+ wwanClientContext->client.openState);
+ chppClientSendOpenRequest(&wwanClientContext->client,
+ &wwanClientContext->outReqStates[CHPP_WWAN_OPEN],
+ CHPP_WWAN_OPEN,
+ /*blocking=*/false);
}
/**
diff --git a/chpp/include/chpp/common/wifi.h b/chpp/include/chpp/common/wifi.h
index c1a6d2b..239a08b 100644
--- a/chpp/include/chpp/common/wifi.h
+++ b/chpp/include/chpp/common/wifi.h
@@ -37,16 +37,9 @@
* Data structures used by the Configure Scan Monitor request.
*/
CHPP_PACKED_START
-struct ChppWifiConfigureScanMonitorAsyncRequestParameters {
- bool enable;
- const void *cookie;
-} CHPP_PACKED_ATTR;
-CHPP_PACKED_END
-
-CHPP_PACKED_START
struct ChppWifiConfigureScanMonitorAsyncRequest {
struct ChppAppHeader header;
- struct ChppWifiConfigureScanMonitorAsyncRequestParameters params;
+ bool enable;
} CHPP_PACKED_ATTR;
CHPP_PACKED_END
diff --git a/chpp/include/chpp/transport.h b/chpp/include/chpp/transport.h
index f25b321..32d8cfe 100644
--- a/chpp/include/chpp/transport.h
+++ b/chpp/include/chpp/transport.h
@@ -38,20 +38,11 @@
***********************************************/
/**
- * CHPP Transport layer reset timeout in ns. The transport layer will attempt
- * another reset if the previous reset is not acked in time.
- */
-#ifndef CHPP_TRANSPORT_RESET_TIMEOUT_NS
-#define CHPP_TRANSPORT_RESET_TIMEOUT_NS \
- (UINT64_C(1500) * CHPP_NSEC_PER_MSEC) // 1500 ms
-#endif
-
-/**
* CHPP Transport layer timeout for tx packets.
*/
#ifndef CHPP_TRANSPORT_TX_TIMEOUT_NS
#define CHPP_TRANSPORT_TX_TIMEOUT_NS \
- (UINT64_C(100) * CHPP_NSEC_PER_MSEC) // 100 ms
+ (UINT64_C(500) * CHPP_NSEC_PER_MSEC) // 500 ms
#endif
/**
@@ -71,6 +62,15 @@
#endif
/**
+ * CHPP Transport layer reset timeout in ns. The transport layer will attempt
+ * another reset if the previous reset is not acked in time.
+ */
+#ifndef CHPP_TRANSPORT_RESET_TIMEOUT_NS
+#define CHPP_TRANSPORT_RESET_TIMEOUT_NS \
+ (UINT64_C(1) * CHPP_TRANSPORT_TX_TIMEOUT_NS * (CHPP_TRANSPORT_MAX_RETX + 1))
+#endif
+
+/**
* CHPP Transport layer maximum reset attempts. Current functional values are 1
* or higher (setting to 0 currently functions identically to 1).
*/
diff --git a/chpp/platform/linux/include/chpp/platform/platform_log.h b/chpp/platform/linux/include/chpp/platform/platform_log.h
index 5fdcda7..604e421 100644
--- a/chpp/platform/linux/include/chpp/platform/platform_log.h
+++ b/chpp/platform/linux/include/chpp/platform/platform_log.h
@@ -37,13 +37,16 @@
// TODO: Should use PRIu8 etc. from inttypes.h instead of %d, etc. (add -Wall
// and -Werror to cflags to catch these)
-#define CHPP_LINUX_LOG(level, color, fmt, ...) \
- { \
- char name[16]; \
- uint64_t ms = chppGetCurrentTimeNs() / 1000000; \
- pthread_getname_np(pthread_self(), name, 16); \
- printf("\e[" color "m[%" PRIu64 "] %s %s:%d\t (%s) " fmt "\e[0m\n", ms, \
- level, __FILENAME__, __LINE__, name, ##__VA_ARGS__); \
+#define CHPP_LINUX_LOG(level, color, fmt, ...) \
+ { \
+ char name[16]; \
+ uint64_t currentTimeMs = chppGetCurrentTimeNs() / 1000000; \
+ uint64_t sec = currentTimeMs / 1000; \
+ uint64_t msec = currentTimeMs % 1000; \
+ pthread_getname_np(pthread_self(), name, 16); \
+ printf("\e[" color "m[%" PRIu64 ".%03" PRIu64 "] %s %s:%d\t (%s) " fmt \
+ "\e[0m\n", \
+ sec, msec, level, __FILENAME__, __LINE__, name, ##__VA_ARGS__); \
}
#define CHPP_LOGE(fmt, ...) CHPP_LINUX_LOG("E", "91", fmt, ##__VA_ARGS__)
diff --git a/chpp/test/fake_link_sync_test.cpp b/chpp/test/fake_link_sync_test.cpp
index f926dd6..d35152b 100644
--- a/chpp/test/fake_link_sync_test.cpp
+++ b/chpp/test/fake_link_sync_test.cpp
@@ -191,4 +191,79 @@
EXPECT_FALSE(mFakeLink->waitForTxPacket());
}
+// This test is essentially CheckRetryOnTimeout but with a twist: we send a
+// packet, then don't send an ACK in the expected time so it gets retried, then
+// after the retry, we send two equivalent ACKs back-to-back
+TEST_F(FakeLinkSyncTests, DelayedThenDupeAck) {
+ // Post the TX packet
+ txPacket();
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ ASSERT_EQ(mFakeLink->getTxPacketCount(), 1);
+ (void)mFakeLink->popTxPacket(); // discard the first packet
+
+ // Second wait should yield timeout + retry
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ ASSERT_EQ(mFakeLink->getTxPacketCount(), 1);
+
+ // Now deliver duplicate ACKs
+ ChppEmptyPacket ack = generateAck(mFakeLink->popTxPacket());
+ chppRxDataCb(&mTransportContext, reinterpret_cast<uint8_t *>(&ack),
+ sizeof(ack));
+ chppRxDataCb(&mTransportContext, reinterpret_cast<uint8_t *>(&ack),
+ sizeof(ack));
+
+ // We shouldn't get another packet (e.g. NAK)
+ EXPECT_FALSE(mFakeLink->waitForTxPacket())
+ << "Got unexpected packet: " << asChpp(mFakeLink->popTxPacket());
+
+ // The next outbound packet should carry the next sequence number
+ txPacket();
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ EXPECT_EQ(asChpp(mFakeLink->popTxPacket()).header.seq, ack.header.ackSeq);
+}
+
+// This tests the opposite side of DelayedThenDuplicateAck: confirms that if we
+// receive a packet, then send an ACK, then we receive a duplicate, we send the
+// ACK again
+TEST_F(FakeLinkSyncTests, ResendAckOnDupe) {
+ // Note that seq and ackSeq should both be 1, since RESET/RESET_ACK will use 0
+ constexpr uint8_t kSeq = 1;
+ constexpr uint8_t kAckSeq = 1;
+ auto rxPkt = generatePacketWithPayload<1>(kAckSeq, kSeq);
+ EXPECT_TRUE(chppRxDataCb(&mTransportContext,
+ reinterpret_cast<const uint8_t *>(&rxPkt),
+ sizeof(rxPkt)));
+
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ ASSERT_EQ(mFakeLink->getTxPacketCount(), 1);
+ std::vector<uint8_t> pkt = mFakeLink->popTxPacket();
+ // We should get an ACK in response
+ EXPECT_TRUE(comparePacket(pkt, generateEmptyPacket(kSeq + 1)))
+ << "Expected first ACK for seq 1 but got: " << asEmptyPacket(pkt);
+
+ // Pretend that we lost that ACK, so resend the same packet
+ EXPECT_TRUE(chppRxDataCb(&mTransportContext,
+ reinterpret_cast<const uint8_t *>(&rxPkt),
+ sizeof(rxPkt)));
+
+ // We should get another ACK that matches the first
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ ASSERT_EQ(mFakeLink->getTxPacketCount(), 1);
+ pkt = mFakeLink->popTxPacket();
+ EXPECT_TRUE(comparePacket(pkt, generateEmptyPacket(kSeq + 1)))
+ << "Expected second ACK for seq 1 but got: " << asEmptyPacket(pkt);
+
+ // Sending another packet should succeed
+ auto secondRxPkt = generatePacketWithPayload<2>(kAckSeq, kSeq + 1);
+ EXPECT_TRUE(chppRxDataCb(&mTransportContext,
+ reinterpret_cast<const uint8_t *>(&secondRxPkt),
+ sizeof(secondRxPkt)));
+
+ ASSERT_TRUE(mFakeLink->waitForTxPacket());
+ ASSERT_EQ(mFakeLink->getTxPacketCount(), 1);
+ pkt = mFakeLink->popTxPacket();
+ EXPECT_TRUE(comparePacket(pkt, generateEmptyPacket(kSeq + 2)))
+ << "Expected ACK for seq 2 but got: " << asEmptyPacket(pkt);
+}
+
} // namespace chpp::test
diff --git a/chpp/test/packet_util.cpp b/chpp/test/packet_util.cpp
index 44a4b42..3617227 100644
--- a/chpp/test/packet_util.cpp
+++ b/chpp/test/packet_util.cpp
@@ -16,6 +16,8 @@
#include "packet_util.h"
+#include "chpp/app.h"
+
#include <cstring>
namespace chpp::test {
@@ -82,19 +84,134 @@
return pkt;
}
-ChppEmptyPacket generateAck(std::vector<uint8_t> &pkt) {
+ChppEmptyPacket generateAck(const std::vector<uint8_t> &pkt) {
// An ACK consists of an empty packet with the ackSeq set to the received
// packet's seq + 1 (since ackSeq indicates the next seq value we expect), and
// seq set to the received packet's ackSeq - 1 (since we don't increment seq
// on empty packets and ackSeq indicates the next expected seq)
- ChppTransportHeader &hdr = getHeader(pkt);
+ const ChppTransportHeader &hdr = getHeader(pkt);
return generateEmptyPacket(/*acqSeq=*/hdr.seq + 1, /*seq=*/hdr.ackSeq - 1);
}
// Utilities for debugging -----------------------------------------------------
+const char *appErrorCodeToStr(uint8_t error) {
+ switch (error) {
+ case CHPP_APP_ERROR_NONE:
+ return "NONE";
+ case CHPP_APP_ERROR_INVALID_COMMAND:
+ return "INVALID_COMMAND";
+ case CHPP_APP_ERROR_INVALID_ARG:
+ return "INVALID_ARG";
+ case CHPP_APP_ERROR_BUSY:
+ return "BUSY";
+ case CHPP_APP_ERROR_OOM:
+ return "OOM";
+ case CHPP_APP_ERROR_UNSUPPORTED:
+ return "UNSUPPORTED";
+ case CHPP_APP_ERROR_TIMEOUT:
+ return "TIMEOUT";
+ case CHPP_APP_ERROR_DISABLED:
+ return "DISABLED";
+ case CHPP_APP_ERROR_RATELIMITED:
+ return "RATELIMITED";
+ case CHPP_APP_ERROR_BLOCKED:
+ return "BLOCKED";
+ case CHPP_APP_ERROR_INVALID_LENGTH:
+ return "INVALID_LENGTH";
+ case CHPP_APP_ERROR_NOT_READY:
+ return "NOT_READY";
+ case CHPP_APP_ERROR_BEYOND_CHPP:
+ return "BEYOND_CHPP";
+ case CHPP_APP_ERROR_UNEXPECTED_RESPONSE:
+ return "UNEXPECTED_RESPONSE";
+ case CHPP_APP_ERROR_CONVERSION_FAILED:
+ return "CONVERSION_FAILED";
+ case CHPP_APP_ERROR_UNSPECIFIED:
+ return "UNSPECIFIED";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *appMessageTypeToStr(uint8_t type) {
+ switch (type) {
+ case CHPP_MESSAGE_TYPE_CLIENT_REQUEST:
+ return "CLIENT_REQ";
+ case CHPP_MESSAGE_TYPE_SERVICE_RESPONSE:
+ return "SERVICE_RESP";
+ case CHPP_MESSAGE_TYPE_CLIENT_NOTIFICATION:
+ return "CLIENT_NOTIF";
+ case CHPP_MESSAGE_TYPE_SERVICE_NOTIFICATION:
+ return "SERVICE_NOTIF";
+ case CHPP_MESSAGE_TYPE_SERVICE_REQUEST:
+ return "SERVICE_REQ";
+ case CHPP_MESSAGE_TYPE_CLIENT_RESPONSE:
+ return "CLIENT_RESP";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+const char *handleToStr(uint8_t handle) {
+ switch (handle) {
+ case CHPP_HANDLE_NONE:
+ return "(NONE)";
+ case CHPP_HANDLE_LOOPBACK:
+ return "(LOOPBACK)";
+ case CHPP_HANDLE_TIMESYNC:
+ return "(TIMESYNC)";
+ case CHPP_HANDLE_DISCOVERY:
+ return "(DISCOVERY)";
+ default:
+ return "";
+ }
+}
+
+const char *packetAttrToStr(uint8_t attr) {
+ switch (attr) {
+ case CHPP_TRANSPORT_ATTR_NONE:
+ return "none";
+ case CHPP_TRANSPORT_ATTR_RESET:
+ return "reset";
+ case CHPP_TRANSPORT_ATTR_RESET_ACK:
+ return "reset-ack";
+ case CHPP_TRANSPORT_ATTR_LOOPBACK_REQUEST:
+ return "loopback-req";
+ case CHPP_TRANSPORT_ATTR_LOOPBACK_RESPONSE:
+ return "loopback-rsp";
+ default:
+ return "invalid";
+ }
+}
+
+const char *transportErrorToStr(uint8_t error) {
+ switch (error) {
+ case CHPP_TRANSPORT_ERROR_NONE:
+ return "none";
+ case CHPP_TRANSPORT_ERROR_CHECKSUM:
+ return "checksum";
+ case CHPP_TRANSPORT_ERROR_OOM:
+ return "oom";
+ case CHPP_TRANSPORT_ERROR_BUSY:
+ return "busy";
+ case CHPP_TRANSPORT_ERROR_HEADER:
+ return "header";
+ case CHPP_TRANSPORT_ERROR_ORDER:
+ return "order";
+ case CHPP_TRANSPORT_ERROR_TIMEOUT:
+ return "timeout";
+ case CHPP_TRANSPORT_ERROR_MAX_RETRIES:
+ return "max-retries";
+ case CHPP_TRANSPORT_ERROR_APPLAYER:
+ return "app-layer";
+ default:
+ return "invalid";
+ }
+}
+
void dumpRaw(std::ostream &os, const void *ptr, size_t len) {
- const char *buffer = static_cast<const char *>(ptr);
+ const uint8_t *buffer = static_cast<const uint8_t *>(ptr);
char line[32];
char lineChars[32];
size_t offset = 0;
@@ -150,64 +267,14 @@
} else {
os << " (finished)";
}
+ uint8_t attr = CHPP_TRANSPORT_GET_ATTR(hdr.packetCode);
+ uint8_t error = CHPP_TRANSPORT_GET_ERROR(hdr.packetCode);
os << std::endl
<< " packetCode: 0x" << std::hex << (unsigned)hdr.packetCode
- << " (attr: ";
- uint8_t attr = CHPP_TRANSPORT_GET_ATTR(hdr.packetCode);
- switch (attr) {
- case CHPP_TRANSPORT_ATTR_NONE:
- os << "none";
- break;
- case CHPP_TRANSPORT_ATTR_RESET:
- os << "reset";
- break;
- case CHPP_TRANSPORT_ATTR_RESET_ACK:
- os << "reset-ack";
- break;
- case CHPP_TRANSPORT_ATTR_LOOPBACK_REQUEST:
- os << "loopback-req";
- break;
- case CHPP_TRANSPORT_ATTR_LOOPBACK_RESPONSE:
- os << "loopback-rsp";
- break;
- default:
- os << "invalid";
- }
- os << " | error: ";
- uint8_t error = CHPP_TRANSPORT_GET_ERROR(hdr.packetCode);
- switch (error) {
- case CHPP_TRANSPORT_ERROR_NONE:
- os << "none";
- break;
- case CHPP_TRANSPORT_ERROR_CHECKSUM:
- os << "checksum";
- break;
- case CHPP_TRANSPORT_ERROR_OOM:
- os << "oom";
- break;
- case CHPP_TRANSPORT_ERROR_BUSY:
- os << "busy";
- break;
- case CHPP_TRANSPORT_ERROR_HEADER:
- os << "header";
- break;
- case CHPP_TRANSPORT_ERROR_ORDER:
- os << "order";
- break;
- case CHPP_TRANSPORT_ERROR_TIMEOUT:
- os << "timeout";
- break;
- case CHPP_TRANSPORT_ERROR_MAX_RETRIES:
- os << "max-retries";
- break;
- case CHPP_TRANSPORT_ERROR_APPLAYER:
- os << "app-layer";
- break;
- default:
- os << "invalid";
- }
- os << ")" << std::endl
- << " ackSeq: " << std::dec << (unsigned)hdr.ackSeq << std::endl
+ << " (attr: " << packetAttrToStr(attr)
+ << " | error: " << transportErrorToStr(error) << ")" << std::endl;
+
+ os << " ackSeq: " << std::dec << (unsigned)hdr.ackSeq << std::endl
<< " seq: " << std::dec << (unsigned)hdr.seq << std::endl
<< " length: " << std::dec << hdr.length << std::endl
<< " reserved: " << std::dec << hdr.reserved << std::endl
@@ -238,9 +305,30 @@
void dumpPacket(std::ostream &os, const ChppPacketPrefix &pkt) {
dumpPreamble(os, pkt.preamble);
dumpHeader(os, pkt.header);
- os << "Payload {" << std::endl;
- dumpRaw(os, pkt.payload, pkt.header.length);
- os << "}" << std::endl;
+ size_t payloadOffset = 0;
+ if (CHPP_TRANSPORT_GET_ATTR(pkt.header.packetCode) ==
+ CHPP_TRANSPORT_ATTR_NONE &&
+ pkt.header.length >= sizeof(ChppAppHeader)) {
+ auto &appHdr = reinterpret_cast<const ChppAppHeader &>(*pkt.payload);
+ os << "AppHeader {" << std::endl;
+ os << " handle: 0x" << std::hex << (unsigned)appHdr.handle << " "
+ << handleToStr(appHdr.handle) << std::endl;
+ os << " type: " << std::dec << (unsigned)appHdr.type << " ("
+ << appMessageTypeToStr(appHdr.type) << ")" << std::endl;
+ os << " transaction: " << std::dec << (unsigned)appHdr.transaction
+ << std::endl;
+ os << " error: " << std::dec << (unsigned)appHdr.error << " ("
+ << appErrorCodeToStr(appHdr.error) << ")" << std::endl;
+ os << " command: " << std::dec << (unsigned)appHdr.command << std::endl;
+ os << "}" << std::endl;
+ payloadOffset = sizeof(ChppAppHeader);
+ }
+ size_t payloadSize = pkt.header.length - payloadOffset;
+ if (payloadSize > 0) {
+ os << "Payload (size " << payloadSize << ") {" << std::endl;
+ dumpRaw(os, &pkt.payload[payloadOffset], pkt.header.length - payloadOffset);
+ os << "}" << std::endl;
+ }
const auto &footer = *reinterpret_cast<const ChppTransportFooter *>(
&pkt.payload[pkt.header.length]);
diff --git a/chpp/test/packet_util.h b/chpp/test/packet_util.h
index faedd08..42bceda 100644
--- a/chpp/test/packet_util.h
+++ b/chpp/test/packet_util.h
@@ -18,12 +18,14 @@
* @file Utilities for working with raw CHPP packets in a test setting
*/
+#include <array>
#include <cinttypes>
#include <iostream>
#include <vector>
#include <gtest/gtest.h>
+#include "chpp/app.h"
#include "chpp/crc.h"
#include "chpp/transport.h"
@@ -53,6 +55,21 @@
uint8_t payload[1]; // Variable size per header.length
} CHPP_PACKED_ATTR;
+template <size_t kPayloadSize>
+struct ChppPacketWithPayload {
+ uint16_t preamble;
+ ChppTransportHeader header;
+ uint8_t payload[kPayloadSize];
+ ChppTransportFooter footer;
+} CHPP_PACKED_ATTR;
+
+struct ChppPacketWithAppHeader {
+ uint16_t preamble;
+ ChppTransportHeader transportHeader;
+ ChppAppHeader appHeader;
+ uint8_t payload[];
+};
+
// Utilities for packet creation -----------------------------------------------
//! Computes the CRC of one of the complete packet types defined above
@@ -68,33 +85,72 @@
uint8_t error = CHPP_TRANSPORT_ERROR_NONE);
//! Create an empty ACK packet for the given packet
-ChppEmptyPacket generateAck(std::vector<uint8_t> &pkt);
+ChppEmptyPacket generateAck(const std::vector<uint8_t> &pkt);
+
+//! Create a packet with payload of the given size. If a payload array is not
+//! provided, it is set to all-zeros.
+template <size_t kPayloadSize>
+ChppPacketWithPayload<kPayloadSize> generatePacketWithPayload(
+ uint8_t ackSeq = 0, uint8_t seq = 0,
+ const std::span<uint8_t, kPayloadSize> *payload = nullptr) {
+ // clang-format off
+ ChppPacketWithPayload<kPayloadSize> pkt = {
+ .preamble = kPreamble,
+ .header = {
+ .flags = CHPP_TRANSPORT_FLAG_FINISHED_DATAGRAM,
+ .packetCode = static_cast<uint8_t>(CHPP_ATTR_AND_ERROR_TO_PACKET_CODE(
+ CHPP_TRANSPORT_ATTR_NONE, CHPP_TRANSPORT_ERROR_NONE)),
+ .ackSeq = ackSeq,
+ .seq = seq,
+ .length = kPayloadSize,
+ .reserved = 0,
+ },
+ };
+ // clang-format on
+ if (payload != nullptr) {
+ std::memcpy(pkt.payload, payload->data(), sizeof(pkt.payload));
+ }
+ pkt.footer.checksum = computeCrc(pkt);
+ return pkt;
+}
// Utilities for packet parsing ------------------------------------------------
-inline ChppEmptyPacket &asEmptyPacket(std::vector<uint8_t> &pkt) {
+inline const ChppEmptyPacket &asEmptyPacket(const std::vector<uint8_t> &pkt) {
EXPECT_EQ(pkt.size(), sizeof(ChppEmptyPacket));
- return *reinterpret_cast<ChppEmptyPacket *>(pkt.data());
+ return *reinterpret_cast<const ChppEmptyPacket *>(pkt.data());
}
-inline ChppResetPacket &asResetPacket(std::vector<uint8_t> &pkt) {
+inline const ChppResetPacket &asResetPacket(const std::vector<uint8_t> &pkt) {
EXPECT_EQ(pkt.size(), sizeof(ChppResetPacket));
- return *reinterpret_cast<ChppResetPacket *>(pkt.data());
+ return *reinterpret_cast<const ChppResetPacket *>(pkt.data());
}
-inline ChppPacketPrefix &asChpp(std::vector<uint8_t> &pkt) {
+inline const ChppPacketPrefix &asChpp(const std::vector<uint8_t> &pkt) {
EXPECT_GE(pkt.size(), sizeof(ChppEmptyPacket));
- return *reinterpret_cast<ChppPacketPrefix *>(pkt.data());
+ return *reinterpret_cast<const ChppPacketPrefix *>(pkt.data());
}
-inline ChppTransportHeader &getHeader(std::vector<uint8_t> &pkt) {
+inline const ChppTransportHeader &getHeader(const std::vector<uint8_t> &pkt) {
static_assert(CHPP_PREAMBLE_LEN_BYTES == sizeof(uint16_t));
EXPECT_GE(pkt.size(), sizeof(uint16_t) + sizeof(ChppTransportHeader));
- return *reinterpret_cast<ChppTransportHeader *>(&pkt[sizeof(uint16_t)]);
+ return *reinterpret_cast<const ChppTransportHeader *>(&pkt[sizeof(uint16_t)]);
+}
+
+inline const ChppPacketWithAppHeader &asApp(const std::vector<uint8_t> &pkt) {
+ EXPECT_GE(pkt.size(),
+ sizeof(ChppPacketWithAppHeader) + sizeof(ChppTransportFooter));
+ return *reinterpret_cast<const ChppPacketWithAppHeader *>(pkt.data());
}
// Utilities for debugging -----------------------------------------------------
+const char *appErrorCodeToStr(uint8_t error);
+const char *appMessageTypeToStr(uint8_t type);
+const char *handleToStr(uint8_t handle);
+const char *packetAttrToStr(uint8_t attr);
+const char *transportErrorToStr(uint8_t error);
+
//! Tuned for outputting a raw binary buffer (e.g. payload or full packet)
void dumpRaw(std::ostream &os, const void *ptr, size_t len);
diff --git a/chpp/transport.c b/chpp/transport.c
index 53687c0..5ba5751 100644
--- a/chpp/transport.c
+++ b/chpp/transport.c
@@ -540,7 +540,7 @@
*/
static void chppProcessResetAck(struct ChppTransportState *context) {
if (context->resetState == CHPP_RESET_STATE_NONE) {
- CHPP_LOGE("Unexpected reset-ack seq=%" PRIu8 " code=0x%" PRIx8,
+ CHPP_LOGW("Unexpected reset-ack seq=%" PRIu8 " code=0x%" PRIx8,
context->rxHeader.seq, context->rxHeader.packetCode);
// In a reset race condition with both endpoints sending resets and
// reset-acks, the sent resets and reset-acks will both have a sequence
@@ -604,8 +604,18 @@
// There are packets to send out (could be new or retx)
// Note: For a future ACK window > 1, makes more sense to cap the NACKs
// to one instead of flooding with out of order NACK errors.
- chppEnqueueTxPacket(context, CHPP_ATTR_AND_ERROR_TO_PACKET_CODE(
- CHPP_TRANSPORT_ATTR_NONE, errorCode));
+
+ // If the sender is retrying a packet we've already received successfully,
+ // send an ACK so it will continue normally
+ enum ChppTransportErrorCode errorCodeToSend = errorCode;
+ if (context->rxHeader.length > 0 &&
+ context->rxHeader.seq == context->rxStatus.expectedSeq - 1) {
+ errorCodeToSend = CHPP_TRANSPORT_ERROR_NONE;
+ }
+
+ chppEnqueueTxPacket(
+ context, CHPP_ATTR_AND_ERROR_TO_PACKET_CODE(CHPP_TRANSPORT_ATTR_NONE,
+ errorCodeToSend));
}
if (errorCode == CHPP_TRANSPORT_ERROR_ORDER) {
@@ -767,7 +777,8 @@
context->rxStatus.receivedAckSeq = rxAckSeq;
if (context->txStatus.txAttempts > 1) {
CHPP_LOGW("Seq %" PRIu8 " ACK'd after %" PRIuSIZE " reTX",
- context->rxHeader.seq, context->txStatus.txAttempts - 1);
+ context->rxHeader.ackSeq - 1,
+ context->txStatus.txAttempts - 1);
}
context->txStatus.txAttempts = 0;
@@ -1560,6 +1571,7 @@
// TODO(b/192359485): Consider removing this function, or making it more robust.
void chppEnqueueTxErrorDatagram(struct ChppTransportState *context,
enum ChppTransportErrorCode errorCode) {
+ chppMutexLock(&context->mutex);
bool resetting = (context->resetState == CHPP_RESET_STATE_RESETTING);
if (resetting) {
CHPP_LOGE("Discarding app error 0x%" PRIx8 " (resetting)", errorCode);
@@ -1582,6 +1594,7 @@
chppEnqueueTxPacket(context, CHPP_ATTR_AND_ERROR_TO_PACKET_CODE(
CHPP_TRANSPORT_ATTR_NONE, errorCode));
}
+ chppMutexUnlock(&context->mutex);
}
uint64_t chppTransportGetTimeUntilNextDoWorkNs(
@@ -1688,11 +1701,13 @@
const uint64_t currentTimeNs = chppGetCurrentTimeNs();
const bool isTxTimeout = currentTimeNs - context->txStatus.lastTxTimeNs >=
CHPP_TRANSPORT_TX_TIMEOUT_NS;
+ const bool isResetting = context->resetState == CHPP_RESET_STATE_RESETTING;
// Call chppTransportDoWork for both TX and request timeouts.
if (isTxTimeout) {
- CHPP_LOGE("ACK timeout. Tx t=%" PRIu64,
- context->txStatus.lastTxTimeNs / CHPP_NSEC_PER_MSEC);
+ CHPP_LOGE("ACK timeout. Tx t=%" PRIu64 ", attempt %zu, isResetting=%d",
+ context->txStatus.lastTxTimeNs / CHPP_NSEC_PER_MSEC,
+ context->txStatus.txAttempts, isResetting);
chppTransportDoWork(context);
} else {
const uint64_t requestTimeoutNs =
@@ -1704,9 +1719,8 @@
}
}
- if ((context->resetState == CHPP_RESET_STATE_RESETTING) &&
- (currentTimeNs - context->resetTimeNs >=
- CHPP_TRANSPORT_RESET_TIMEOUT_NS)) {
+ if (isResetting && (currentTimeNs - context->resetTimeNs >=
+ CHPP_TRANSPORT_RESET_TIMEOUT_NS)) {
if (context->resetCount + 1 < CHPP_TRANSPORT_MAX_RESET) {
CHPP_LOGE("RESET-ACK timeout; retrying");
context->resetCount++;
@@ -1714,6 +1728,7 @@
CHPP_TRANSPORT_ERROR_TIMEOUT);
} else {
CHPP_LOGE("RESET-ACK timeout; giving up");
+ context->txStatus.txAttempts = 0;
context->resetState = CHPP_RESET_STATE_PERMANENT_FAILURE;
chppClearTxDatagramQueue(context);
}
diff --git a/chre_api/CMakeLists.txt b/chre_api/CMakeLists.txt
new file mode 100644
index 0000000..26e429d
--- /dev/null
+++ b/chre_api/CMakeLists.txt
@@ -0,0 +1,34 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+include(backend.cmake)
+
+# The interface which provides the base CHRE API for nanoapps including
+# "chre.h", "chre/version.h", etc.
+#
+# Note that this does not implement the interface, this is done either by the
+# runtime or the nanoapp support lib DSO for dynamic nanoapp builds -- neither
+# of which nanoapps are permitted to directly depend on.
+pw_add_facade(chre.chre_api INTERFACE
+ BACKEND
+ chre.chre_api_BACKEND
+ HEADERS
+ include/chre_api/chre.h
+ include/chre_api/chre/audio.h
+ include/chre_api/chre/ble.h
+ include/chre_api/chre/common.h
+ include/chre_api/chre/event.h
+ include/chre_api/chre/gnss.h
+ include/chre_api/chre/nanoapp.h
+ include/chre_api/chre/re.h
+ include/chre_api/chre/sensor.h
+ include/chre_api/chre/sensor_types.h
+ include/chre_api/chre/toolchain.h
+ include/chre_api/chre/user_settings.h
+ include/chre_api/chre/version.h
+ include/chre_api/chre/wifi.h
+ include/chre_api/chre/wwan.h
+ PUBLIC_INCLUDES
+ include
+ include/chre_api
+ PUBLIC_DEPS
+ chre.variant.config
+)
diff --git a/chre_api/backend.cmake b/chre_api/backend.cmake
new file mode 100644
index 0000000..e4c9d8b
--- /dev/null
+++ b/chre_api/backend.cmake
@@ -0,0 +1,6 @@
+include_guard(GLOBAL)
+
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+# Backend for chre.chre_api.
+pw_add_backend_variable(chre.chre_api_BACKEND)
diff --git a/chre_api/include/chre_api/chre/ble.h b/chre_api/include/chre_api/chre/ble.h
index dc8e900..230fe7d 100644
--- a/chre_api/include/chre_api/chre/ble.h
+++ b/chre_api/include/chre_api/chre/ble.h
@@ -56,16 +56,16 @@
* @{
*/
//! No BLE APIs are supported
-#define CHRE_BLE_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_BLE_CAPABILITIES_NONE (UINT32_C(0))
//! CHRE supports BLE scanning
-#define CHRE_BLE_CAPABILITIES_SCAN UINT32_C(1 << 0)
+#define CHRE_BLE_CAPABILITIES_SCAN (UINT32_C(1) << 0)
//! CHRE BLE supports batching of scan results, either through Android-specific
//! HCI (OCF: 0x156), or by the CHRE framework, internally.
//! @since v1.7 Platforms with this capability must also support flushing scan
//! results during a batched scan.
-#define CHRE_BLE_CAPABILITIES_SCAN_RESULT_BATCHING UINT32_C(1 << 1)
+#define CHRE_BLE_CAPABILITIES_SCAN_RESULT_BATCHING (UINT32_C(1) << 1)
//! CHRE BLE scan supports best-effort hardware filtering. If filtering is
//! available, chreBleGetFilterCapabilities() returns a bitmap indicating the
@@ -74,10 +74,14 @@
//! must be met for this flag:
//! If only one nanoapp is requesting BLE scans and there are no BLE scans from
//! the AP, only filtered results will be provided to the nanoapp.
-#define CHRE_BLE_CAPABILITIES_SCAN_FILTER_BEST_EFFORT UINT32_C(1 << 2)
+#define CHRE_BLE_CAPABILITIES_SCAN_FILTER_BEST_EFFORT (UINT32_C(1) << 2)
//! CHRE BLE supports reading the RSSI of a specified LE-ACL connection handle.
-#define CHRE_BLE_CAPABILITIES_READ_RSSI UINT32_C(1 << 3)
+#define CHRE_BLE_CAPABILITIES_READ_RSSI (UINT32_C(1) << 3)
+
+//! CHRE supports offloading a Bluetooth connection socket for bidirectional
+//! data transfer over a Connection-Oriented Channel (COC).
+#define CHRE_BLE_CAPABILITIES_LE_COC_SOCKET UINT32_C (UINT32_C(1) << 4)
/** @} */
/**
@@ -95,24 +99,24 @@
* @{
*/
//! No CHRE BLE filters are supported
-#define CHRE_BLE_FILTER_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_BLE_FILTER_CAPABILITIES_NONE (UINT32_C(0))
//! CHRE BLE supports RSSI filters
-#define CHRE_BLE_FILTER_CAPABILITIES_RSSI UINT32_C(1 << 1)
+#define CHRE_BLE_FILTER_CAPABILITIES_RSSI (UINT32_C(1) << 1)
//! CHRE BLE supports Broadcaster Address filters (Corresponding HCI OCF:
//! 0x0157, Sub-command: 0x02)
//! @since v1.9
-#define CHRE_BLE_FILTER_CAPABILITIES_BROADCASTER_ADDRESS UINT32_C(1 << 2)
+#define CHRE_BLE_FILTER_CAPABILITIES_BROADCASTER_ADDRESS (UINT32_C(1) << 2)
//! CHRE BLE supports Manufacturer Data filters (Corresponding HCI OCF: 0x0157,
//! Sub-command: 0x06)
//! @since v1.8
-#define CHRE_BLE_FILTER_CAPABILITIES_MANUFACTURER_DATA UINT32_C(1 << 6)
+#define CHRE_BLE_FILTER_CAPABILITIES_MANUFACTURER_DATA (UINT32_C(1) << 6)
//! CHRE BLE supports Service Data filters (Corresponding HCI OCF: 0x0157,
//! Sub-command: 0x07)
-#define CHRE_BLE_FILTER_CAPABILITIES_SERVICE_DATA UINT32_C(1 << 7)
+#define CHRE_BLE_FILTER_CAPABILITIES_SERVICE_DATA (UINT32_C(1) << 7)
/** @} */
/**
@@ -194,6 +198,47 @@
*/
#define CHRE_EVENT_BLE_SCAN_STATUS_CHANGE CHRE_BLE_EVENT_ID(5)
+/**
+ * nanoappHandleEvent argument: struct chreBleSocketConnectionEvent
+ *
+ * This is a unicast event that is sent to a nanoapp when an offloaded socket is
+ * connected and is available to be used by the nanoapp. The nanoapp must call
+ * chreBleSocketAccept() to accept ownership of the socket and
+ * subscribe to CHRE_EVENT_BLE_SOCKET_PACKET events.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_BLE_SOCKET_CONNECTION CHRE_BLE_EVENT_ID(6)
+
+/**
+ * nanoappHandleEvent argument: struct chreBleSocketDisconnectionEvent
+ *
+ * This is a unicast event that is sent to a nanoapp when an offloaded socket is
+ * disconnected and can no longer be used by the nanoapp.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_BLE_SOCKET_DISCONNECTION CHRE_BLE_EVENT_ID(7)
+
+/**
+ * nanoappHandleEvent argument: struct chreBleSocketPacketEvent
+ *
+ * This event is sent when the nanoapp receives a packet from the offload
+ * socket.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_BLE_SOCKET_PACKET CHRE_BLE_EVENT_ID(8)
+
+/**
+ * nanoappHandleEvent argument: NULL
+ *
+ * This event is sent when the socket is available to send packets again.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_BLE_SOCKET_SEND_AVAILABLE CHRE_BLE_EVENT_ID(9)
+
// NOTE: Do not add new events with ID > 15
/** @} */
@@ -677,6 +722,102 @@
};
/**
+ * Notifies a nanoapp that a socket has been connected and offloaded and is
+ * ready to be used. The nanoapp is expected to accept ownership of the socket
+ * by calling the chreBleSocketAccept() API. If the nanoapp does not accept
+ * ownership of the socket, the transfer of ownership to the nanoapp is aborted.
+ *
+ * @since v1.11
+ */
+struct chreBleSocketConnectionEvent {
+ //! Unique identifier for this socket connection. This ID in CHRE matches the
+ //! ID used on the host side. It is valid only while the socket is connected.
+ uint64_t socketId;
+
+ //! Descriptive socket name provided by the host app that initiated the socket
+ //! offload request. This is not guaranteed to be unique across the system,
+ //! but can help the offload app understand the purpose of the socket when it
+ //! receives a socket connection event. This pointer is only valid for the
+ //! duration of the event.
+ const char *socketName;
+
+ //! When sending a packet to the socket via chreBleSocketSend(), the length
+ //! must not exceed this value.
+ uint16_t maxTxPacketLength;
+
+ //! When the nanoapp receives packets from the socket via the
+ //! chreBleSocketPacketEvent, the length will not exceed this value.
+ uint16_t maxRxPacketLength;
+};
+
+/**
+ * Notifies a nanoapp that a socket has been disconnected and can no longer be
+ * used by the nanoapp. Once a socket is disconnected, the same socket ID will
+ * not be reconnected. If the nanoapp wants to continue using an offloaded
+ * socket, a new offloaded socket must be created and connected.
+ *
+ * @since v1.11
+ */
+struct chreBleSocketDisconnectionEvent {
+ //! @see chreBleSocketConnectionEvent.socketId
+ uint64_t socketId;
+};
+
+/**
+ * Notifies a nanoapp that it has received a packet from a socket.
+ *
+ * @since v1.11
+ */
+struct chreBleSocketPacketEvent {
+ //! @see chreBleSocketConnectionEvent.socketId
+ uint64_t socketId;
+
+ //! Length of data in bytes. The length will not exceed the maxRxPacketLength
+ //! provided in the CHRE event CHRE_EVENT_BLE_SOCKET_CONNECTION.
+ uint16_t length;
+
+ //! Packet payload that is length bytes.
+ const uint8_t *data;
+};
+
+/**
+ * Result code used with chreBleSocketSend().
+ *
+ * @since v1.11
+ */
+enum chreBleSocketSendStatus {
+ //! The packet has successfully been sent to the platform layer.
+ CHRE_BLE_SOCKET_SEND_STATUS_SUCCESS = 1,
+
+ //! The packet will not be sent.
+ CHRE_BLE_SOCKET_SEND_STATUS_FAILURE = 2,
+
+ //! The packet cannot be sent at this time because too many packets are in
+ //! flight. The nanoapp will be notified via a
+ //! CHRE_EVENT_BLE_SOCKET_SEND_AVAILABLE event when the socket is available to
+ //! send the packet.
+ CHRE_BLE_SOCKET_SEND_STATUS_QUEUE_FULL = 3,
+};
+
+/**
+ * Callback which frees the packet sent via chreBleSocketSend().
+ *
+ * This callback is (optionally) provided to the chreBleSocketSend() function as
+ * a means for freeing the packet. When this callback is invoked, the packet is
+ * no longer needed and can be released. Note that this in no way assures that
+ * said packet was sent to the offload socket, simply that this memory is no
+ * longer needed.
+ *
+ * @param data The data argument from chreBleSocketSend().
+ * @param length The length argument from chreBleSocketSend().
+ *
+ * @see chreBleSocketSend()
+ *
+ * @since v1.11
+ */
+typedef void(chreBleSocketPacketFreeFunction)(void *data, uint16_t length);
+
+/**
* Retrieves a set of flags indicating the BLE features supported by the
* current CHRE implementation. The value returned by this function must be
* consistent for the entire duration of the nanoapp's execution.
@@ -938,6 +1079,52 @@
bool chreBleGetScanStatus(struct chreBleScanStatus *status);
/**
+ * Accepts that this nanoapp owns the socket and subscribes to
+ * CHRE_EVENT_BLE_SOCKET_PACKET events from this socket. This API is only
+ * valid to call while handling the CHRE_EVENT_BLE_SOCKET_CONNECTION event.
+ *
+ * @param socketId @see chreBleSocketConnectionEvent.socketId
+ * @return True if CHRE confirms that socket ownership has been transferred.
+ *
+ * @since v1.11
+ */
+bool chreBleSocketAccept(uint64_t socketId);
+
+/**
+ * Sends a packet to the socket with the corresponding socketId. This API can
+ * only be used after the nanoapp has received a
+ * CHRE_EVENT_BLE_SOCKET_CONNECTION event indicating the offloaded socket is
+ * connected and has accepted ownership of the socket by calling
+ * chreBleSocketAccept().
+ *
+ * NOTE: freeCallback WILL NOT be invoked if the return status is
+ * CHRE_BLE_SOCKET_SEND_STATUS_QUEUE_FULL.
+ *
+ * @param socketId @see chreBleSocketConnectionEvent.socketId
+ * @param data Packet to be sent to the socket that is length bytes. After this
+ * API is called, ownership of this memory passes to CHRE and the nanoapp
+ * must ensure that the packet remains valid and unmodified until the
+ * freeCallback is invoked.
+ * @param length Length of packet to be sent to the socket in bytes. Cannot
+ * exceed the maxTxPacketLength provided in the CHRE event
+ * CHRE_EVENT_BLE_SOCKET_CONNECTION.
+ * @param freeCallback Callback invoked to indicate that the packet data buffer
+ * is not needed by CHRE anymore. Note that invocation of this function does
+ * not mean that the packet has been delivered, only that memory can be
+ * released. This is guaranteed to be invoked if this function returns
+ * CHRE_BLE_SOCKET_SEND_STATUS_SUCCESS or
+ * CHRE_BLE_SOCKET_SEND_STATUS_FAILURE, but WILL NOT be invoked for
+ * CHRE_BLE_SOCKET_SEND_STATUS_QUEUE_FULL. This may be invoked
+ * synchronously, so nanoapp developers should not call chreBleSocketSend()
+ * from within the callback to avoid potential infinite recursion.
+ * @return A value from enum chreBleSocketSendStatus.
+ *
+ * @since v1.11
+ */
+int32_t chreBleSocketSend(uint64_t socketId, const void *data, uint16_t length,
+ chreBleSocketPacketFreeFunction *freeCallback);
+
+/**
* Definitions for handling unsupported CHRE BLE scenarios.
*/
#else // defined(CHRE_NANOAPP_USES_BLE) || !defined(CHRE_IS_NANOAPP_BUILD)
@@ -958,6 +1145,15 @@
#define chreBleReadRssiAsync(...) \
CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleReadRssiAsync")
+#define chreBleGetScanStatus(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleGetScanStatus")
+
+#define chreBleSocketAccept(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleSocketAccept")
+
+#define chreBleSocketSend(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleSocketSend")
+
#endif // defined(CHRE_NANOAPP_USES_BLE) || !defined(CHRE_IS_NANOAPP_BUILD)
#ifdef __cplusplus
diff --git a/chre_api/include/chre_api/chre/event.h b/chre_api/include/chre_api/chre/event.h
index d08b7d0..fb56733 100644
--- a/chre_api/include/chre_api/chre/event.h
+++ b/chre_api/include/chre_api/chre/event.h
@@ -26,6 +26,7 @@
*/
#include <stdbool.h>
+#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
@@ -202,6 +203,31 @@
#define CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT UINT16_C(0x000B)
/**
+ * nanoappHandleEvent argument: struct chreMessageFromEndpointData
+ *
+ * The format of the 'message' part of this structure is left undefined,
+ * and it's up to the nanoapp and endpoint to have an established protocol
+ * beforehand.
+ *
+ * On receiving the first message from an endpoint, the nanoapp can assume
+ * a session with the sessionId has been created and can be used to send
+ * messages to the endpoint. The nanoapp will receive a
+ * CHRE_EVENT_ENDPOINT_SESSION_CLOSED event when the session is closed.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_MESSAGE_FROM_ENDPOINT UINT16_C(0x000C)
+
+/**
+ * nanoappHandleEvent argument: struct chreEndpointSessionClosedData
+ *
+ * Indicates that a session with an endpoint has been closed.
+ *
+ * @since v1.11
+ */
+#define CHRE_EVENT_ENDPOINT_SESSION_CLOSED UINT16_C(0x000D)
+
+/**
* First possible value for CHRE_EVENT_SENSOR events.
*
* This allows us to separately define our CHRE_EVENT_SENSOR_* events in
@@ -425,6 +451,68 @@
};
/**
+ * Data provided with CHRE_EVENT_MESSAGE_FROM_ENDPOINT.
+ */
+struct chreMessageFromEndpointData {
+ /**
+ * Message type supplied by the endpoint.
+ */
+ uint32_t messageType;
+
+ /**
+ * Message permissions supplied by the endpoint. The format is specified by
+ * the CHRE_MESSAGE_PERMISSION_* values if the endpoint is a nanoapp, else
+ * it is specified by the endpoint. These permissions are enforced by CHRE.
+ * A nanoapp without the required permissions will not receive the message.
+ */
+ uint32_t messagePermissions;
+
+ /**
+ * The message from the endpoint.
+ *
+ * These contents are of a format that the endpoint and nanoapp must have
+ * established beforehand.
+ *
+ * This data is 'messageSize' bytes in length. Note that if 'messageSize'
+ * is 0, this might contain NULL.
+ */
+ const void *message;
+
+ /**
+ * The size, in bytes of the following 'message'.
+ *
+ * This can be 0.
+ */
+ size_t messageSize;
+
+ /**
+ * The session ID of the message. A session is the active connection between
+ * two endpoints. The receiving nanoapp or endpoint initiated the session
+ * before sending this message. If the nanoapp has not yet received a
+ * message with this session ID, it can assume the session was created by
+ * the nanoapp or other endpoint. The nanoapp may send messages to the other
+ * endpoint with this session ID.
+ */
+ uint16_t sessionId;
+};
+
+/**
+ * Data provided with CHRE_EVENT_ENDPOINT_SESSION_CLOSED.
+ */
+struct chreEndpointSessionClosedData {
+ /**
+ * The message hub ID and endpoint ID of the other party in the session.
+ */
+ uint64_t hubId;
+ uint64_t endpointId;
+
+ /**
+ * The ID of the session that was closed.
+ */
+ uint16_t sessionId;
+};
+
+/**
* Provides metadata for a nanoapp in the system.
*/
struct chreNanoappInfo {
@@ -471,7 +559,7 @@
*/
uint8_t rpcServiceCount;
- /*
+ /**
* Array of RPC services published by this nanoapp.
* Services are published via chrePublishRpcServices.
* The array contains rpcServiceCount entries.
diff --git a/chre_api/include/chre_api/chre/gnss.h b/chre_api/include/chre_api/chre/gnss.h
index a326e85..75d0168 100644
--- a/chre_api/include/chre_api/chre/gnss.h
+++ b/chre_api/include/chre_api/chre/gnss.h
@@ -55,21 +55,21 @@
*/
//! A lack of flags indicates that GNSS is not supported in this CHRE
-#define CHRE_GNSS_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_GNSS_CAPABILITIES_NONE (UINT32_C(0))
//! GNSS position fixes are supported via chreGnssLocationSessionStartAsync()
-#define CHRE_GNSS_CAPABILITIES_LOCATION UINT32_C(1 << 0)
+#define CHRE_GNSS_CAPABILITIES_LOCATION (UINT32_C(1) << 0)
//! GNSS raw measurements are supported via
//! chreGnssMeasurementSessionStartAsync()
-#define CHRE_GNSS_CAPABILITIES_MEASUREMENTS UINT32_C(1 << 1)
+#define CHRE_GNSS_CAPABILITIES_MEASUREMENTS (UINT32_C(1) << 1)
//! Location fixes supplied from chreGnssConfigurePassiveLocationListener()
//! are tapped in at the GNSS engine level, so they include additional fixes
//! such as those requested by the AP, and not just those requested by other
//! nanoapps within CHRE (which is the case when this flag is not set)
#define CHRE_GNSS_CAPABILITIES_GNSS_ENGINE_BASED_PASSIVE_LISTENER \
- UINT32_C(1 << 2)
+ (UINT32_C(1) << 2)
/** @} */
@@ -120,34 +120,34 @@
// Flags indicating the Accumulated Delta Range's states
// (ref: GnssAccumulatedDeltaRangeState)
-#define CHRE_GNSS_ADR_STATE_UNKNOWN UINT16_C(0)
-#define CHRE_GNSS_ADR_STATE_VALID UINT16_C(1 << 0)
-#define CHRE_GNSS_ADR_STATE_RESET UINT16_C(1 << 1)
-#define CHRE_GNSS_ADR_STATE_CYCLE_SLIP UINT16_C(1 << 2)
+#define CHRE_GNSS_ADR_STATE_UNKNOWN (UINT16_C(0))
+#define CHRE_GNSS_ADR_STATE_VALID (UINT16_C(1) << 0)
+#define CHRE_GNSS_ADR_STATE_RESET (UINT16_C(1) << 1)
+#define CHRE_GNSS_ADR_STATE_CYCLE_SLIP (UINT16_C(1) << 2)
// Flags to indicate what fields in chreGnssClock are valid (ref: GnssClockFlags)
-#define CHRE_GNSS_CLOCK_HAS_LEAP_SECOND UINT16_C(1 << 0)
-#define CHRE_GNSS_CLOCK_HAS_TIME_UNCERTAINTY UINT16_C(1 << 1)
-#define CHRE_GNSS_CLOCK_HAS_FULL_BIAS UINT16_C(1 << 2)
-#define CHRE_GNSS_CLOCK_HAS_BIAS UINT16_C(1 << 3)
-#define CHRE_GNSS_CLOCK_HAS_BIAS_UNCERTAINTY UINT16_C(1 << 4)
-#define CHRE_GNSS_CLOCK_HAS_DRIFT UINT16_C(1 << 5)
-#define CHRE_GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY UINT16_C(1 << 6)
+#define CHRE_GNSS_CLOCK_HAS_LEAP_SECOND (UINT16_C(1) << 0)
+#define CHRE_GNSS_CLOCK_HAS_TIME_UNCERTAINTY (UINT16_C(1) << 1)
+#define CHRE_GNSS_CLOCK_HAS_FULL_BIAS (UINT16_C(1) << 2)
+#define CHRE_GNSS_CLOCK_HAS_BIAS (UINT16_C(1) << 3)
+#define CHRE_GNSS_CLOCK_HAS_BIAS_UNCERTAINTY (UINT16_C(1) << 4)
+#define CHRE_GNSS_CLOCK_HAS_DRIFT (UINT16_C(1) << 5)
+#define CHRE_GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY (UINT16_C(1) << 6)
// Flags to indicate which values are valid in a GpsLocation
// (ref: GpsLocationFlags)
-#define CHRE_GPS_LOCATION_HAS_LAT_LONG UINT16_C(1 << 0)
-#define CHRE_GPS_LOCATION_HAS_ALTITUDE UINT16_C(1 << 1)
-#define CHRE_GPS_LOCATION_HAS_SPEED UINT16_C(1 << 2)
-#define CHRE_GPS_LOCATION_HAS_BEARING UINT16_C(1 << 3)
-#define CHRE_GPS_LOCATION_HAS_ACCURACY UINT16_C(1 << 4)
+#define CHRE_GPS_LOCATION_HAS_LAT_LONG (UINT16_C(1) << 0)
+#define CHRE_GPS_LOCATION_HAS_ALTITUDE (UINT16_C(1) << 1)
+#define CHRE_GPS_LOCATION_HAS_SPEED (UINT16_C(1) << 2)
+#define CHRE_GPS_LOCATION_HAS_BEARING (UINT16_C(1) << 3)
+#define CHRE_GPS_LOCATION_HAS_ACCURACY (UINT16_C(1) << 4)
//! @since v1.3
-#define CHRE_GPS_LOCATION_HAS_ALTITUDE_ACCURACY UINT16_C(1 << 5)
+#define CHRE_GPS_LOCATION_HAS_ALTITUDE_ACCURACY (UINT16_C(1) << 5)
//! @since v1.3
-#define CHRE_GPS_LOCATION_HAS_SPEED_ACCURACY UINT16_C(1 << 6)
+#define CHRE_GPS_LOCATION_HAS_SPEED_ACCURACY (UINT16_C(1) << 6)
//! @since v1.3
-#define CHRE_GPS_LOCATION_HAS_BEARING_ACCURACY UINT16_C(1 << 7)
+#define CHRE_GPS_LOCATION_HAS_BEARING_ACCURACY (UINT16_C(1) << 7)
/**
* The maximum number of instances of struct chreGnssMeasurement that may be
@@ -161,21 +161,21 @@
#define CHRE_GNSS_MAX_MEASUREMENT_PRE_1_5 UINT8_C(64)
// Flags indicating the GNSS measurement state (ref: GnssMeasurementState)
-#define CHRE_GNSS_MEASUREMENT_STATE_UNKNOWN UINT16_C(0)
-#define CHRE_GNSS_MEASUREMENT_STATE_CODE_LOCK UINT16_C(1 << 0)
-#define CHRE_GNSS_MEASUREMENT_STATE_BIT_SYNC UINT16_C(1 << 1)
-#define CHRE_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC UINT16_C(1 << 2)
-#define CHRE_GNSS_MEASUREMENT_STATE_TOW_DECODED UINT16_C(1 << 3)
-#define CHRE_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS UINT16_C(1 << 4)
-#define CHRE_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC UINT16_C(1 << 5)
-#define CHRE_GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC UINT16_C(1 << 6)
-#define CHRE_GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED UINT16_C(1 << 7)
-#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC UINT16_C(1 << 8)
-#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC UINT16_C(1 << 9)
-#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK UINT16_C(1 << 10)
-#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK UINT16_C(1 << 11)
-#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC UINT16_C(1 << 12)
-#define CHRE_GNSS_MEASUREMENT_STATE_SBAS_SYNC UINT16_C(1 << 13)
+#define CHRE_GNSS_MEASUREMENT_STATE_UNKNOWN (UINT16_C(0))
+#define CHRE_GNSS_MEASUREMENT_STATE_CODE_LOCK (UINT16_C(1) << 0)
+#define CHRE_GNSS_MEASUREMENT_STATE_BIT_SYNC (UINT16_C(1) << 1)
+#define CHRE_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC (UINT16_C(1) << 2)
+#define CHRE_GNSS_MEASUREMENT_STATE_TOW_DECODED (UINT16_C(1) << 3)
+#define CHRE_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS (UINT16_C(1) << 4)
+#define CHRE_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC (UINT16_C(1) << 5)
+#define CHRE_GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC (UINT16_C(1) << 6)
+#define CHRE_GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED (UINT16_C(1) << 7)
+#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC (UINT16_C(1) << 8)
+#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC (UINT16_C(1) << 9)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK (UINT16_C(1) << 10)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK (UINT16_C(1) << 11)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC (UINT16_C(1) << 12)
+#define CHRE_GNSS_MEASUREMENT_STATE_SBAS_SYNC (UINT16_C(1) << 13)
#define CHRE_GNSS_MEASUREMENT_CARRIER_FREQUENCY_UNKNOWN 0.f
diff --git a/chre_api/include/chre_api/chre/re.h b/chre_api/include/chre_api/chre/re.h
index 8d76987..24ebff6 100644
--- a/chre_api/include/chre_api/chre/re.h
+++ b/chre_api/include/chre_api/chre/re.h
@@ -73,11 +73,11 @@
*/
//! None of the optional capabilities are supported
-#define CHRE_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_CAPABILITIES_NONE (UINT32_C(0))
//! Support for reliable messages.
//! @see chreSendReliableMessageAsync()
-#define CHRE_CAPABILITIES_RELIABLE_MESSAGES UINT32_C(1 << 0)
+#define CHRE_CAPABILITIES_RELIABLE_MESSAGES (UINT32_C(1) << 0)
/** @} */
diff --git a/chre_api/include/chre_api/chre/version.h b/chre_api/include/chre_api/chre/version.h
index 8f4e3d6..3dc4984 100644
--- a/chre_api/include/chre_api/chre/version.h
+++ b/chre_api/include/chre_api/chre/version.h
@@ -164,12 +164,22 @@
* This version of the CHRE API is shipped with Android V. It adds support for
* reliable messaging.
*
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_10 UINT32_C(0x010a0000)
+
+/**
+ * Value for version 1.11 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with Android 16. It adds definitions
+ * for WWAN Cell Neighbors.
+ *
* @note This version of the CHRE API has not been finalized yet, and is
* currently considered a preview that is subject to change.
*
* @see CHRE_API_VERSION
*/
-#define CHRE_API_VERSION_1_10 UINT32_C(0x010a0000)
+#define CHRE_API_VERSION_1_11 UINT32_C(0x010b0000)
/**
* Major and Minor Version of this Context Hub Runtime Environment API.
@@ -188,7 +198,7 @@
* Note that version numbers can always be numerically compared with
* expected results, so 1.0.0 < 1.0.4 < 1.1.0 < 2.0.300 < 3.5.0.
*/
-#define CHRE_API_VERSION CHRE_API_VERSION_1_10
+#define CHRE_API_VERSION CHRE_API_VERSION_1_11
/**
* Utility macro to extract only the API major version of a composite CHRE
diff --git a/chre_api/include/chre_api/chre/wifi.h b/chre_api/include/chre_api/chre/wifi.h
index 44d3d41..e02f419 100644
--- a/chre_api/include/chre_api/chre/wifi.h
+++ b/chre_api/include/chre_api/chre/wifi.h
@@ -64,29 +64,29 @@
*/
//! No WiFi APIs are supported
-#define CHRE_WIFI_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_WIFI_CAPABILITIES_NONE (UINT32_C(0))
//! Listening to scan results is supported, as enabled via
//! chreWifiConfigureScanMonitorAsync()
-#define CHRE_WIFI_CAPABILITIES_SCAN_MONITORING UINT32_C(1 << 0)
+#define CHRE_WIFI_CAPABILITIES_SCAN_MONITORING (UINT32_C(1) << 0)
//! Requesting WiFi scans on-demand is supported via chreWifiRequestScanAsync()
-#define CHRE_WIFI_CAPABILITIES_ON_DEMAND_SCAN UINT32_C(1 << 1)
+#define CHRE_WIFI_CAPABILITIES_ON_DEMAND_SCAN (UINT32_C(1) << 1)
//! Specifying the radio chain preference in on-demand scan requests, and
//! reporting it in scan events is supported
//! @since v1.2
-#define CHRE_WIFI_CAPABILITIES_RADIO_CHAIN_PREF UINT32_C(1 << 2)
+#define CHRE_WIFI_CAPABILITIES_RADIO_CHAIN_PREF (UINT32_C(1) << 2)
//! Requesting RTT ranging is supported via chreWifiRequestRangingAsync()
//! @since v1.2
-#define CHRE_WIFI_CAPABILITIES_RTT_RANGING UINT32_C(1 << 3)
+#define CHRE_WIFI_CAPABILITIES_RTT_RANGING (UINT32_C(1) << 3)
//! Specifies if WiFi NAN service subscription is supported. If a platform
//! supports subscriptions, then it must also support RTT ranging for NAN
//! services via chreWifiNanRequestRangingAsync()
//! @since v1.6
-#define CHRE_WIFI_CAPABILITIES_NAN_SUB UINT32_C(1 << 4)
+#define CHRE_WIFI_CAPABILITIES_NAN_SUB (UINT32_C(1) << 4)
/** @} */
@@ -226,8 +226,8 @@
* @{
*/
-#define CHRE_WIFI_BAND_MASK_2_4_GHZ UINT8_C(1 << 0) //!< 2.4 GHz
-#define CHRE_WIFI_BAND_MASK_5_GHZ UINT8_C(1 << 1) //!< 5 GHz
+#define CHRE_WIFI_BAND_MASK_2_4_GHZ (UINT8_C(1) << 0) //!< 2.4 GHz
+#define CHRE_WIFI_BAND_MASK_5_GHZ (UINT8_C(1) << 1) //!< 5 GHz
/** @} */
@@ -237,17 +237,17 @@
* @{
*/
-#define CHRE_WIFI_SCAN_RESULT_FLAGS_NONE UINT8_C(0)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_NONE UINT8_C(0)
//! Element ID 61 (HT Operation) is present (see HT 7.3.2)
-#define CHRE_WIFI_SCAN_RESULT_FLAGS_HT_OPS_PRESENT UINT8_C(1 << 0)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_HT_OPS_PRESENT (UINT8_C(1) << 0)
//! Element ID 192 (VHT Operation) is present (see VHT 8.4.2)
-#define CHRE_WIFI_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT UINT8_C(1 << 1)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT (UINT8_C(1) << 1)
//! Element ID 127 (Extended Capabilities) is present, and bit 70 (Fine Timing
//! Measurement Responder) is set to 1 (see IEEE Std 802.11-2016 9.4.2.27)
-#define CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER UINT8_C(1 << 2)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER (UINT8_C(1) << 2)
//! Retained for backwards compatibility
//! @see CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER
@@ -256,12 +256,13 @@
//! HT Operation element indicates that a secondary channel is present
//! (see HT 7.3.2.57)
-#define CHRE_WIFI_SCAN_RESULT_FLAGS_HAS_SECONDARY_CHANNEL_OFFSET UINT8_C(1 << 3)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_HAS_SECONDARY_CHANNEL_OFFSET \
+ (UINT8_C(1) << 3)
//! HT Operation element indicates that the secondary channel is below the
//! primary channel (see HT 7.3.2.57)
#define CHRE_WIFI_SCAN_RESULT_FLAGS_SECONDARY_CHANNEL_OFFSET_IS_BELOW \
- UINT8_C(1 << 4)
+ (UINT8_C(1) << 4)
/** @} */
@@ -273,23 +274,23 @@
* @{
*/
-#define CHRE_WIFI_SECURITY_MODE_UNKNOWN UINT8_C(0)
+#define CHRE_WIFI_SECURITY_MODE_UNKNOWN (UINT8_C(0))
//! @deprecated since v1.10. Use CHRE_WIFI_SECURITY_MODE_UNKNOWN instead.
-#define CHRE_WIFI_SECURITY_MODE_UNKONWN CHRE_WIFI_SECURITY_MODE_UNKNOWN
+#define CHRE_WIFI_SECURITY_MODE_UNKONWN CHRE_WIFI_SECURITY_MODE_UNKNOWN
-#define CHRE_WIFI_SECURITY_MODE_OPEN UINT8_C(1 << 0) //!< No auth/security
-#define CHRE_WIFI_SECURITY_MODE_WEP UINT8_C(1 << 1)
-#define CHRE_WIFI_SECURITY_MODE_PSK UINT8_C(1 << 2) //!< WPA-PSK or WPA2-PSK
-#define CHRE_WIFI_SECURITY_MODE_EAP UINT8_C(1 << 3) //!< WPA-EAP or WPA2-EAP
+#define CHRE_WIFI_SECURITY_MODE_OPEN (UINT8_C(1) << 0) //!< No auth/security
+#define CHRE_WIFI_SECURITY_MODE_WEP (UINT8_C(1) << 1)
+#define CHRE_WIFI_SECURITY_MODE_PSK (UINT8_C(1) << 2) //!< WPA-PSK or WPA2-PSK
+#define CHRE_WIFI_SECURITY_MODE_EAP (UINT8_C(1) << 3) //!< WPA-EAP or WPA2-EAP
//! @since v1.5
-#define CHRE_WIFI_SECURITY_MODE_SAE UINT8_C(1 << 4)
+#define CHRE_WIFI_SECURITY_MODE_SAE (UINT8_C(1) << 4)
//! @since v1.5
-#define CHRE_WIFI_SECURITY_MODE_EAP_SUITE_B UINT8_C(1 << 5)
+#define CHRE_WIFI_SECURITY_MODE_EAP_SUITE_B (UINT8_C(1) << 5)
//! @since v1.5
-#define CHRE_WIFI_SECURITY_MODE_OWE UINT8_C(1 << 6)
+#define CHRE_WIFI_SECURITY_MODE_OWE (UINT8_C(1) << 6)
/** @} */
@@ -300,9 +301,9 @@
* @{
*/
-#define CHRE_WIFI_RADIO_CHAIN_UNKNOWN UINT8_C(0)
-#define CHRE_WIFI_RADIO_CHAIN_0 UINT8_C(1 << 0)
-#define CHRE_WIFI_RADIO_CHAIN_1 UINT8_C(1 << 1)
+#define CHRE_WIFI_RADIO_CHAIN_UNKNOWN (UINT8_C(0))
+#define CHRE_WIFI_RADIO_CHAIN_0 (UINT8_C(1) << 0)
+#define CHRE_WIFI_RADIO_CHAIN_1 (UINT8_C(1) << 1)
/** @} */
@@ -320,7 +321,7 @@
//! If set, the nested chreWifiLci structure is populated; otherwise it is
//! invalid and must be ignored
-#define CHRE_WIFI_RTT_RESULT_HAS_LCI UINT8_C(1 << 0)
+#define CHRE_WIFI_RTT_RESULT_HAS_LCI (UINT8_C(1) << 0)
/** @} */
@@ -1281,6 +1282,8 @@
* @param cookie An opaque value that will be included in the chreAsyncResult
* sent in relation to this request.
* @return true if the request was accepted for processing, false otherwise.
+ * @since v1.6
+ * @note Requires WiFi permission
*/
bool chreWifiNanRequestRangingAsync(const struct chreWifiNanRangingParams *params,
const void *cookie);
diff --git a/chre_api/include/chre_api/chre/wwan.h b/chre_api/include/chre_api/chre/wwan.h
index dc46182..80cbf3d 100644
--- a/chre_api/include/chre_api/chre/wwan.h
+++ b/chre_api/include/chre_api/chre/wwan.h
@@ -58,10 +58,16 @@
*/
//! No WWAN APIs are supported
-#define CHRE_WWAN_CAPABILITIES_NONE UINT32_C(0)
+#define CHRE_WWAN_CAPABILITIES_NONE (UINT32_C(0))
//! Current cell information can be queried via chreWwanGetCellInfoAsync()
-#define CHRE_WWAN_GET_CELL_INFO UINT32_C(1 << 0)
+#define CHRE_WWAN_GET_CELL_INFO (UINT32_C(1) << 0)
+
+//! The chreWwanCellInfoResult from chreWwanGetCellInfoAsync() will include
+//! all available chreWwanCellInfo as entries in cells, not just a single
+//! primary result.
+//! @since v1.11 - Neighbor support in prior versions of the API is unspecified.
+#define CHRE_WWAN_GET_CELL_NEIGHBOR_INFO (UINT32_C(1) << 1)
/** @} */
diff --git a/chre_api/legacy/v1_10/chre.h b/chre_api/legacy/v1_10/chre.h
new file mode 100644
index 0000000..9b87d08
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre.h
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _CHRE_H_
+#define _CHRE_H_
+
+/**
+ * @file
+ * This header file includes all the headers which combine to fully define the
+ * interface for the Context Hub Runtime Environment (CHRE). This interface is
+ * of interest to both implementers of CHREs and authors of nanoapps. The API
+ * documentation attempts to address concerns of both.
+ *
+ * See individual header files for API details, and general comments below
+ * for overall platform information.
+ */
+
+#include <chre/audio.h>
+#include <chre/ble.h>
+#include <chre/common.h>
+#include <chre/event.h>
+#include <chre/gnss.h>
+#include <chre/nanoapp.h>
+#include <chre/re.h>
+#include <chre/sensor.h>
+#include <chre/toolchain.h>
+#include <chre/user_settings.h>
+#include <chre/version.h>
+#include <chre/wifi.h>
+#include <chre/wwan.h>
+
+/**
+ * @mainpage
+ * CHRE is the Context Hub Runtime Environment. CHRE is used in Android to run
+ * contextual applications, called nanoapps, in a low-power processing domain
+ * other than the applications processor that runs Android itself. The CHRE
+ * API, documented herein, is the common interface exposed to nanoapps for any
+ * compatible CHRE implementation. The CHRE API provides the ability for
+ * creating nanoapps that are code-compatible across different CHRE
+ * implementations and underlying platforms. Refer to the following sections for
+ * a discussion on some important details of CHRE that aren't explicitly exposed
+ * in the API itself.
+ *
+ * @section entry_points Entry points
+ *
+ * The following entry points are used to bind a nanoapp to the CHRE system, and
+ * all three must be implemented by any nanoapp (see chre/nanoapp.h):
+ * - nanoappStart: initialization
+ * - nanoappHandleEvent: hook for event-driven processing
+ * - nanoappEnd: graceful teardown
+ *
+ * The CHRE implementation must also ensure that it performs these functions
+ * prior to invoking nanoappStart, or after nanoappEnd returns:
+ * - bss section zeroed out (prior to nanoappStart)
+ * - static variables initialized (prior to nanoappStart)
+ * - global C++ constructors called (prior to nanoappStart)
+ * - global C++ destructors called (after nanoappEnd)
+ *
+ * @section threading Threading model
+ *
+ * A CHRE implementation is free to choose among many different
+ * threading models, including a single-threaded system or a multi-threaded
+ * system with preemption. The current platform definition is agnostic to this
+ * underlying choice. However, the CHRE implementation must ensure that time
+ * spent executing within a nanoapp does not significantly degrade or otherwise
+ * interfere with other functions of the system in which CHRE is implemented,
+ * especially latency-sensitive tasks such as sensor event delivery to the AP.
+ * In other words, it must ensure that these functions can either occur in
+ * parallel or preempt a nanoapp's execution. The current version of the API
+ * does not specify whether the implementation allows for CPU sharing between
+ * nanoapps on a more granular level than the handling of individual events [1].
+ * In any case, event ordering from the perspective of an individual nanoapp
+ * must be FIFO, but the CHRE implementation may choose to violate total
+ * ordering of events across all nanoapps to achieve more fair resource sharing,
+ * but this is not required.
+ *
+ * This version of the CHRE API does require that all nanoapps are treated as
+ * non-reentrant, meaning that only one instance of program flow can be inside
+ * an individual nanoapp at any given time. That is, any of the functions of
+ * the nanoapp, including the entry points and all other callbacks, cannot be
+ * invoked if a previous invocation to the same or any other function in the
+ * nanoapp has not completed yet.
+ *
+ * For example, if a nanoapp is currently in nanoappHandleEvent(), the CHRE is
+ * not allowed to call nanoappHandleEvent() again, or to call a memory freeing
+ * callback. Similarly, if a nanoapp is currently in a memory freeing
+ * callback, the CHRE is not allowed to call nanoappHandleEvent(), or invoke
+ * another memory freeing callback.
+ *
+ * There are two exceptions to this rule: If an invocation of chreSendEvent()
+ * fails (returns 'false'), it is allowed to immediately invoke the memory
+ * freeing callback passed into that function. This is a rare case, and one
+ * where otherwise a CHRE implementation is likely to leak memory. Similarly,
+ * chreSendMessageToHost() is allowed to invoke the memory freeing callback
+ * directly, whether it returns 'true' or 'false'. This is because the CHRE
+ * implementation may copy the message data to its own buffer, and therefore
+ * wouldn't need the nanoapp-supplied buffer after chreSendMessageToHost()
+ * returns.
+ *
+ * For a nanoapp author, this means no thought needs to be given to
+ * synchronization issues with global objects, as they will, by definition,
+ * only be accessed by a single thread at once.
+ *
+ * [1]: Note to CHRE implementers: A future version of the CHRE platform may
+ * require multi-threading with preemption. This is mentioned as a heads up,
+ * and to allow implementors deciding between implementation approaches to
+ * make the most informed choice.
+ *
+ * @section timing Timing
+ *
+ * Nanoapps should expect to be running on a highly constrained system, with
+ * little memory and little CPU. Any single nanoapp should expect to
+ * be one of several nanoapps on the system, which also share the CPU with the
+ * CHRE and possibly other services as well.
+ *
+ * Thus, a nanoapp needs to be efficient in its memory and CPU usage.
+ * Also, as noted in the Threading Model section, a CHRE implementation may
+ * be single threaded. As a result, all methods invoked in a nanoapp
+ * (like nanoappStart, nanoappHandleEvent, memory free callbacks, etc.)
+ * must run "quickly". "Quickly" is difficult to define, as there is a
+ * diversity of Context Hub hardware. Nanoapp authors are strongly recommended
+ * to limit their application to consuming no more than 1 second of CPU time
+ * prior to returning control to the CHRE implementation. A CHRE implementation
+ * may consider a nanoapp as unresponsive if it spends more time than this to
+ * process a single event, and take corrective action.
+ *
+ * A nanoapp may have the need to occasionally perform a large block of
+ * calculations that exceeds the 1 second guidance. The recommended approach in
+ * this case is to split up the large block of calculations into smaller
+ * batches. In one call into the nanoapp, the nanoapp can perform the first
+ * batch, and then set a timer or send an event (chreSendEvent()) to itself
+ * indicating which batch should be done next. This will allow the nanoapp to
+ * perform the entire calculation over time, without monopolizing system
+ * resources.
+ *
+ * @section floats Floating point support
+ *
+ * The C type 'float' is used in this API, and thus a CHRE implementation
+ * is required to support 'float's.
+ *
+ * Support of the C types 'double' and 'long double' is optional for a
+ * CHRE implementation. Note that if a CHRE decides to support them, unlike
+ * 'float' support, there is no requirement that this support is particularly
+ * efficient. So nanoapp authors should be aware this may be inefficient.
+ *
+ * If a CHRE implementation chooses not to support 'double' or
+ * 'long double', then the build toolchain setup provided needs to set
+ * the preprocessor define CHRE_NO_DOUBLE_SUPPORT.
+ *
+ * @section compat CHRE and Nanoapp compatibility
+ *
+ * CHRE implementations must make affordances to maintain binary compatibility
+ * across minor revisions of the API version (e.g. v1.1 to v1.2). This applies
+ * to both running a nanoapp compiled for a newer version of the API on a CHRE
+ * implementation built against an older version (backwards compatibility), and
+ * vice versa (forwards compatibility). API changes that are acceptable in
+ * minor version changes that may require special measures to ensure binary
+ * compatibility include: addition of new functions; addition of arguments to
+ * existing functions when the default value used for nanoapps compiled against
+ * the old version is well-defined and does not affect existing functionality;
+ * and addition of fields to existing structures, even when this induces a
+ * binary layout change (this should be made rare via judicious use of reserved
+ * fields). API changes that must only occur alongside a major version change
+ * and are therefore not compatible include: removal of any function, argument,
+ * field in a data structure, or mandatory functional behavior that a nanoapp
+ * may depend on; any change in the interpretation of an existing data structure
+ * field that alters the way it was defined previously (changing the units of a
+ * field would fall under this, but appropriating a previously reserved field
+ * for some new functionality would not); and any change in functionality or
+ * expected behavior that conflicts with the previous definition.
+ *
+ * Note that the CHRE API only specifies the software interface between a
+ * nanoapp and the CHRE system - the binary interface (ABI) between nanoapp and
+ * CHRE is necessarily implementation-dependent. Therefore, the recommended
+ * approach to accomplish binary compatibility is to build a Nanoapp Support
+ * Library (NSL) that is specific to the CHRE implementation into the nanoapp
+ * binary, and use it to handle ABI details in a way that ensures compatibility.
+ * In addition, to accomplish forwards compatibility, the CHRE implementation is
+ * expected to recognize the CHRE API version that a nanoapp is targeting and
+ * engage compatibility behaviors where necessary.
+ *
+ * By definition, major API version changes (e.g. v1.1 to v2.0) break
+ * compatibility. Therefore, a CHRE implementation must not attempt to load a
+ * nanoapp that is targeting a newer major API version.
+ */
+
+#endif /* _CHRE_H_ */
+
diff --git a/chre_api/legacy/v1_10/chre/audio.h b/chre_api/legacy/v1_10/chre/audio.h
new file mode 100644
index 0000000..085329e
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/audio.h
@@ -0,0 +1,432 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_AUDIO_H_
+#define _CHRE_AUDIO_H_
+
+/**
+ * @file
+ * The API for requesting audio in the Context Hub Runtime Environment.
+ *
+ * This includes the definition of audio data structures and the ability to
+ * request audio streams.
+ */
+
+#include <chre/event.h>
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The current compatibility version of the chreAudioDataEvent structure.
+ */
+#define CHRE_AUDIO_DATA_EVENT_VERSION UINT8_C(1)
+
+/**
+ * Produce an event ID in the block of IDs reserved for audio
+ * @param offset Index into audio event ID block; valid range [0,15]
+ */
+#define CHRE_AUDIO_EVENT_ID(offset) (CHRE_EVENT_AUDIO_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreAudioSourceStatusEvent
+ *
+ * Indicates a change in the format and/or rate of audio data provided to a
+ * nanoapp.
+ */
+#define CHRE_EVENT_AUDIO_SAMPLING_CHANGE CHRE_AUDIO_EVENT_ID(0)
+
+/**
+ * nanoappHandleEvent argument: struct chreAudioDataEvent
+ *
+ * Provides a buffer of audio data to a nanoapp.
+ */
+#define CHRE_EVENT_AUDIO_DATA CHRE_AUDIO_EVENT_ID(1)
+
+/**
+ * The maximum size of the name of an audio source including the
+ * null-terminator.
+ */
+#define CHRE_AUDIO_SOURCE_NAME_MAX_SIZE (40)
+
+/**
+ * Helper values for sample rates.
+ *
+ * @defgroup CHRE_AUDIO_SAMPLE_RATES
+ * @{
+ */
+
+//! 16kHz Audio Sample Data
+#define CHRE_AUDIO_SAMPLE_RATE_16KHZ (16000)
+
+/** @} */
+
+/**
+ * Formats for audio that can be provided to a nanoapp.
+ */
+enum chreAudioDataFormat {
+ /**
+ * Unsigned, 8-bit u-Law encoded data as specified by ITU-T G.711.
+ */
+ CHRE_AUDIO_DATA_FORMAT_8_BIT_U_LAW = 0,
+
+ /**
+ * Signed, 16-bit linear PCM data. Endianness must be native to the local
+ * processor.
+ */
+ CHRE_AUDIO_DATA_FORMAT_16_BIT_SIGNED_PCM = 1,
+};
+
+/**
+ * A description of an audio source available to a nanoapp.
+ *
+ * This provides a description of an audio source with a name and a
+ * description of the format of the provided audio data.
+ */
+struct chreAudioSource {
+ /**
+ * A human readable name for this audio source. This is a C-style,
+ * null-terminated string. The length must be less than or equal to
+ * CHRE_AUDIO_SOURCE_NAME_MAX_SIZE bytes (including the null-terminator) and
+ * is expected to describe the source of the audio in US English. All
+ * characters must be printable (i.e.: isprint would return true for all
+ * characters in the name for the EN-US locale). The typical use of this field
+ * is for a nanoapp to log the name of the audio source that it is using.
+ *
+ * Example: "Camcorder Microphone"
+ */
+ const char *name;
+
+ /**
+ * The sampling rate in hertz of this mode. This value is rounded to the
+ * nearest integer. Typical values might include 16000, 44100 and 44800.
+ *
+ * If the requested audio source is preempted by another feature of the system
+ * (e.g. hotword), a gap may occur in received audio data. This is indicated
+ * to the client by posting a CHRE_EVENT_AUDIO_SAMPLING_CHANGE event. The
+ * nanoapp will then receive another CHRE_EVENT_AUDIO_SAMPLING_CHANGE event
+ * once the audio source is available again.
+ */
+ uint32_t sampleRate;
+
+ /**
+ * The minimum amount of time that this audio source can be buffered, in
+ * nanoseconds. Audio data is delivered to nanoapps in buffers. This specifies
+ * the minimum amount of data that can be delivered to a nanoapp without
+ * losing data. A request for a buffer that is smaller than this will fail.
+ */
+ uint64_t minBufferDuration;
+
+ /**
+ * The maximum amount of time that this audio source can be buffered, in
+ * nanoseconds. Audio data is delivered to nanoapps in buffers. This specifies
+ * the maximum amount of data that can be stored by the system in one event
+ * without losing data. A request for a buffer that is larger than this will
+ * fail.
+ */
+ uint64_t maxBufferDuration;
+
+ /**
+ * The format for data provided to the nanoapp. This will be assigned to one
+ * of the enum chreAudioDataFormat values.
+ */
+ uint8_t format;
+};
+
+/**
+ * The current status of an audio source.
+ */
+struct chreAudioSourceStatus {
+ /**
+ * Set to true if the audio source is currently enabled by this nanoapp. If
+ * this struct is provided by a CHRE_EVENT_AUDIO_SAMPLING_CHANGE event, it
+ * must necessarily be set to true because sampling change events are only
+ * sent for sources which this nanoapp has actively subscribed to. If this
+ * struct is obtained from the chreAudioGetStatus API, it may be set to true
+ * or false depending on if audio is currently enabled.
+ */
+ bool enabled;
+
+ /**
+ * Set to true if the audio source is currently suspended and no audio data
+ * will be received from this source.
+ */
+ bool suspended;
+};
+
+/**
+ * The nanoappHandleEvent argument for CHRE_EVENT_AUDIO_SAMPLING_CHANGE.
+ */
+struct chreAudioSourceStatusEvent {
+ /**
+ * The audio source which has completed a status change.
+ */
+ uint32_t handle;
+
+ /**
+ * The status of this audio source.
+ */
+ struct chreAudioSourceStatus status;
+};
+
+/**
+ * The nanoappHandleEvent argument for CHRE_EVENT_AUDIO_DATA.
+ *
+ * One example of the sequence of events for a nanoapp to receive audio data is:
+ *
+ * 1. CHRE_EVENT_AUDIO_SAMPLING_CHANGE - Indicates that audio data is not
+ * suspended.
+ * 2. CHRE_EVENT_AUDIO_DATA - One buffer of audio samples. Potentially repeated.
+ * 3. CHRE_EVENT_AUDIO_SAMPLING_CHANGE - Indicates that audio data has suspended
+ * which indicates a gap in the audio.
+ * 4. CHRE_EVENT_AUDIO_SAMPLING_CHANGE - Indicates that audio data has resumed
+ * and that audio data may be delivered
+ * again if enough samples are buffered.
+ * 5. CHRE_EVENT_AUDIO_DATA - One buffer of audio samples. Potentially repeated.
+ * The nanoapp must tolerate a gap in the timestamps.
+ *
+ * This process repeats for as long as an active request is made for an audio
+ * source. A CHRE_EVENT_AUDIO_SAMPLING_CHANGE does not guarantee that the next
+ * event will be a CHRE_EVENT_AUDIO_DATA event when suspended is set to false.
+ * It may happen that the audio source is suspended before a complete buffer can
+ * be captured. This will cause another CHRE_EVENT_AUDIO_SAMPLING_CHANGE event
+ * to be dispatched with suspended set to true before a buffer is delivered.
+ *
+ * Audio events must be delivered to a nanoapp in order.
+ */
+struct chreAudioDataEvent {
+ /**
+ * Indicates the version of the structure, for compatibility purposes. Clients
+ * do not normally need to worry about this field; the CHRE implementation
+ * guarantees that the client only receives the structure version it expects.
+ */
+ uint8_t version;
+
+ /**
+ * Additional bytes reserved for future use; must be set to 0.
+ */
+ uint8_t reserved[3];
+
+ /**
+ * The handle for which this audio data originated from.
+ */
+ uint32_t handle;
+
+ /**
+ * The base timestamp for this buffer of audio data, from the same time base
+ * as chreGetTime() (in nanoseconds). The audio API does not provide
+ * timestamps for each audio sample. This timestamp corresponds to the first
+ * sample of the buffer. Even though the value is expressed in nanoseconds,
+ * there is an expectation that the sample clock may drift and nanosecond
+ * level accuracy may not be possible. The goal is to be as accurate as
+ * possible within reasonable limitations of a given system.
+ */
+ uint64_t timestamp;
+
+ /**
+ * The sample rate for this buffer of data in hertz, rounded to the nearest
+ * integer. Fractional sampling rates are not supported. Typical values might
+ * include 16000, 44100 and 48000.
+ */
+ uint32_t sampleRate;
+
+ /**
+ * The number of samples provided with this buffer.
+ */
+ uint32_t sampleCount;
+
+ /**
+ * The format of this audio data. This enumeration and union of pointers below
+ * form a tagged struct. The consumer of this API must use this enum to
+ * determine which samples pointer below to dereference. This will be assigned
+ * to one of the enum chreAudioDataFormat values.
+ */
+ uint8_t format;
+
+ /**
+ * A union of pointers to various formats of sample data. These correspond to
+ * the valid chreAudioDataFormat values.
+ */
+ union {
+ const uint8_t *samplesULaw8;
+ const int16_t *samplesS16;
+ };
+};
+
+/**
+ * Retrieves information about an audio source supported by the current CHRE
+ * implementation. The source returned by the runtime must not change for the
+ * entire lifecycle of the Nanoapp and hot-pluggable audio sources are not
+ * supported.
+ *
+ * A simple example of iterating all available audio sources is provided here:
+ *
+ * struct chreAudioSource audioSource;
+ * for (uint32_t i = 0; chreAudioGetSource(i, &audioSource); i++) {
+ * chreLog(CHRE_LOG_INFO, "Found audio source: %s", audioSource.name);
+ * }
+ *
+ * Handles provided to this API must be a stable value for the entire duration
+ * of a nanoapp. Handles for all audio sources must be zero-indexed and
+ * contiguous. The following are examples of handles that could be provided to
+ * this API:
+ *
+ * Valid: 0
+ * Valid: 0, 1, 2, 3
+ * Invalid: 1, 2, 3
+ * Invalid: 0, 2
+ *
+ * @param handle The handle for an audio source to obtain details for. The
+ * range of acceptable handles must be zero-indexed and contiguous.
+ * @param audioSource A struct to populate with details of the audio source.
+ * @return true if the query was successful, false if the provided handle is
+ * invalid or the supplied audioSource is NULL.
+ *
+ * @since v1.2
+ */
+bool chreAudioGetSource(uint32_t handle, struct chreAudioSource *audioSource);
+
+/**
+ * Nanoapps must define CHRE_NANOAPP_USES_AUDIO somewhere in their build
+ * system (e.g. Makefile) if the nanoapp needs to use the following audio APIs.
+ * In addition to allowing access to these APIs, defining this macro will also
+ * ensure CHRE enforces that all host clients this nanoapp talks to have the
+ * required Android permissions needed to listen to audio data by adding
+ * metadata to the nanoapp.
+ */
+#if defined(CHRE_NANOAPP_USES_AUDIO) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+/**
+ * Configures delivery of audio data to the current nanoapp. Note that this may
+ * not fully disable the audio source if it is used by other clients in the
+ * system but it will halt data delivery to the nanoapp.
+ *
+ * The bufferDuration and deliveryInterval parameters as described below are
+ * used together to determine both how much and how often to deliver data to a
+ * nanoapp, respectively. A nanoapp will always be provided the requested
+ * amount of data at the requested interval, even if another nanoapp in CHRE
+ * requests larger/more frequent buffers or smaller/less frequent buffers.
+ * These two buffering parameters allow describing the duty cycle of captured
+ * audio data. If a nanoapp wishes to receive all available audio data, it will
+ * specify a bufferDuration and deliveryInterval that are equal. A 50% duty
+ * cycle would be achieved by specifying a deliveryInterval that is double the
+ * value of the bufferDuration provided. These parameters allow the audio
+ * subsystem to operate at less than 100% duty cycle and permits use of
+ * incomplete audio data without periodic reconfiguration of the source.
+ *
+ * Two examples are illustrated below:
+ *
+ * Target duty cycle: 50%
+ * bufferDuration: 2
+ * deliveryInterval: 4
+ *
+ * Time 0 1 2 3 4 5 6 7
+ * Batch A B
+ * Sample -- -- a1 a2 -- -- b1 b2
+ * Duration [ ] [ ]
+ * Interval [ ] [ ]
+ *
+ *
+ * Target duty cycle: 100%
+ * bufferDuration: 4
+ * deliveryInterval: 4
+ *
+ * Time 0 1 2 3 4 5 6 7
+ * Batch A B
+ * Sample a1 a2 a3 a4 b1 b2 b3 b4
+ * Duration [ ] [ ]
+ * Interval [ ] [ ]
+ *
+ *
+ * This is expected to reduce power overall.
+ *
+ * The first audio buffer supplied to the nanoapp may contain data captured
+ * prior to the request. This could happen if the microphone was already enabled
+ * and reading into a buffer prior to the nanoapp requesting audio data for
+ * itself. The nanoapp must tolerate this.
+ *
+ * It is important to note that multiple logical audio sources (e.g. different
+ * sample rate, format, etc.) may map to one physical audio source. It is
+ * possible for a nanoapp to request audio data from more than one logical
+ * source at a time. Audio data may be suspended for either the current or other
+ * requests. The CHRE_EVENT_AUDIO_SAMPLING_CHANGE will be posted to all clients
+ * if such a change occurs. It is also possible for the request to succeed and
+ * all audio sources are serviced simultaneously. This is implementation defined
+ * but at least one audio source must function correctly if it is advertised,
+ * under normal conditions (e.g. not required for some other system function,
+ * such as hotword).
+ *
+ * @param handle The handle for this audio source. The handle for the desired
+ * audio source can be determined using chreAudioGetSource().
+ * @param enable true if enabling the source, false otherwise. When passed as
+ * false, the bufferDuration and deliveryInterval parameters are ignored.
+ * @param bufferDuration The amount of time to capture audio samples from this
+ * audio source, in nanoseconds per delivery interval. This value must be
+ * in the range of minBufferDuration/maxBufferDuration for this source or
+ * the request will fail. The number of samples captured per buffer will be
+ * derived from the sample rate of the source and the requested duration and
+ * rounded down to the nearest sample boundary.
+ * @param deliveryInterval Desired time between each CHRE_EVENT_AUDIO_DATA
+ * event. This allows specifying the complete duty cycle of a request
+ * for audio data, in nanoseconds. This value must be greater than or equal
+ * to bufferDuration or the request will fail due to an invalid
+ * configuration.
+ * @return true if the configuration was successful, false if invalid parameters
+ * were provided (non-existent handle, invalid buffering configuration).
+ *
+ * @since v1.2
+ * @note Requires audio permission
+ */
+bool chreAudioConfigureSource(uint32_t handle, bool enable,
+ uint64_t bufferDuration,
+ uint64_t deliveryInterval);
+
+/**
+ * Gets the current chreAudioSourceStatus struct for a given audio handle.
+ *
+ * @param handle The handle for the audio source to query. The provided handle
+ * is obtained from a chreAudioSource which is requested from the
+ * chreAudioGetSource API.
+ * @param status The current status of the supplied audio source.
+ * @return true if the provided handle is valid and the status was obtained
+ * successfully, false if the handle was invalid or status is NULL.
+ *
+ * @since v1.2
+ * @note Requires audio permission
+ */
+bool chreAudioGetStatus(uint32_t handle, struct chreAudioSourceStatus *status);
+
+#else /* defined(CHRE_NANOAPP_USES_AUDIO) || !defined(CHRE_IS_NANOAPP_BUILD) */
+#define CHRE_AUDIO_PERM_ERROR_STRING \
+ "CHRE_NANOAPP_USES_AUDIO must be defined when building this nanoapp in " \
+ "order to refer to "
+#define chreAudioConfigureSource(...) \
+ CHRE_BUILD_ERROR(CHRE_AUDIO_PERM_ERROR_STRING "chreAudioConfigureSource")
+#define chreAudioGetStatus(...) \
+ CHRE_BUILD_ERROR(CHRE_AUDIO_PERM_ERROR_STRING "chreAudioGetStatus")
+#endif /* defined(CHRE_NANOAPP_USES_AUDIO) || !defined(CHRE_IS_NANOAPP_BUILD) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_AUDIO_H_ */
diff --git a/chre_api/legacy/v1_10/chre/ble.h b/chre_api/legacy/v1_10/chre/ble.h
new file mode 100644
index 0000000..dc8e900
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/ble.h
@@ -0,0 +1,967 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef CHRE_BLE_H_
+#define CHRE_BLE_H_
+
+/**
+ * @file
+ * CHRE BLE (Bluetooth Low Energy, Bluetooth LE) API.
+ * The CHRE BLE API currently supports BLE scanning features.
+ *
+ * The features in the CHRE BLE API are a subset and adaptation of Android
+ * capabilities as described in the Android BLE API and HCI requirements.
+ * ref:
+ * https://developer.android.com/guide/topics/connectivity/bluetooth/ble-overview
+ * ref: https://source.android.com/devices/bluetooth/hci_requirements
+ *
+ * All byte arrays in the CHRE BLE API follow the byte order used OTA unless
+ * specified otherwise, and multi-byte types, for example uint16_t, follow the
+ * processor's native byte order. One notable exception is addresses. Address
+ * fields in both scan filters and advertising reports must be in big endian
+ * byte order to match the Android Bluetooth API (ref:
+ * https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#getRemoteDevice(byte[])).
+ */
+
+#include <chre/common.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The set of flags returned by chreBleGetCapabilities().
+ *
+ * @defgroup CHRE_BLE_CAPABILITIES
+ * @{
+ */
+//! No BLE APIs are supported
+#define CHRE_BLE_CAPABILITIES_NONE UINT32_C(0)
+
+//! CHRE supports BLE scanning
+#define CHRE_BLE_CAPABILITIES_SCAN UINT32_C(1 << 0)
+
+//! CHRE BLE supports batching of scan results, either through Android-specific
+//! HCI (OCF: 0x156), or by the CHRE framework, internally.
+//! @since v1.7 Platforms with this capability must also support flushing scan
+//! results during a batched scan.
+#define CHRE_BLE_CAPABILITIES_SCAN_RESULT_BATCHING UINT32_C(1 << 1)
+
+//! CHRE BLE scan supports best-effort hardware filtering. If filtering is
+//! available, chreBleGetFilterCapabilities() returns a bitmap indicating the
+//! specific filtering capabilities that are supported.
+//! To differentiate best-effort vs. no filtering, the following requirement
+//! must be met for this flag:
+//! If only one nanoapp is requesting BLE scans and there are no BLE scans from
+//! the AP, only filtered results will be provided to the nanoapp.
+#define CHRE_BLE_CAPABILITIES_SCAN_FILTER_BEST_EFFORT UINT32_C(1 << 2)
+
+//! CHRE BLE supports reading the RSSI of a specified LE-ACL connection handle.
+#define CHRE_BLE_CAPABILITIES_READ_RSSI UINT32_C(1 << 3)
+/** @} */
+
+/**
+ * The set of flags returned by chreBleGetFilterCapabilities().
+ *
+ * The representative bit for each filtering capability is based on the sub-OCF
+ * of the Android filtering HCI vendor-specific command (LE_APCF_Command, OCF:
+ * 0x0157) for that particular filtering capability, as found in
+ * https://source.android.com/devices/bluetooth/hci_requirements
+ *
+ * For example, the Service Data filter has a sub-command of 0x7; hence
+ * the filtering capability is indicated by (1 << 0x7).
+ *
+ * @defgroup CHRE_BLE_FILTER_CAPABILITIES
+ * @{
+ */
+//! No CHRE BLE filters are supported
+#define CHRE_BLE_FILTER_CAPABILITIES_NONE UINT32_C(0)
+
+//! CHRE BLE supports RSSI filters
+#define CHRE_BLE_FILTER_CAPABILITIES_RSSI UINT32_C(1 << 1)
+
+//! CHRE BLE supports Broadcaster Address filters (Corresponding HCI OCF:
+//! 0x0157, Sub-command: 0x02)
+//! @since v1.9
+#define CHRE_BLE_FILTER_CAPABILITIES_BROADCASTER_ADDRESS UINT32_C(1 << 2)
+
+//! CHRE BLE supports Manufacturer Data filters (Corresponding HCI OCF: 0x0157,
+//! Sub-command: 0x06)
+//! @since v1.8
+#define CHRE_BLE_FILTER_CAPABILITIES_MANUFACTURER_DATA UINT32_C(1 << 6)
+
+//! CHRE BLE supports Service Data filters (Corresponding HCI OCF: 0x0157,
+//! Sub-command: 0x07)
+#define CHRE_BLE_FILTER_CAPABILITIES_SERVICE_DATA UINT32_C(1 << 7)
+/** @} */
+
+/**
+ * Produce an event ID in the block of IDs reserved for BLE.
+ *
+ * Valid input range is [0, 15]. Do not add new events with ID > 15
+ * (see chre/event.h)
+ *
+ * @param offset Index into BLE event ID block; valid range is [0, 15].
+ *
+ * @defgroup CHRE_BLE_EVENT_ID
+ * @{
+ */
+#define CHRE_BLE_EVENT_ID(offset) (CHRE_EVENT_BLE_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreAsyncResult
+ *
+ * Communicates the asynchronous result of a request to the BLE API. The
+ * requestType field in {@link #chreAsyncResult} is set to a value from enum
+ * chreBleRequestType.
+ *
+ * This is used for results of async config operations which need to
+ * interop with lower level code (potentially in a different thread) or send an
+ * HCI command to the FW and wait on the response.
+ */
+#define CHRE_EVENT_BLE_ASYNC_RESULT CHRE_BLE_EVENT_ID(0)
+
+/**
+ * nanoappHandleEvent argument: struct chreBleAdvertisementEvent
+ *
+ * Provides results of a BLE scan.
+ */
+#define CHRE_EVENT_BLE_ADVERTISEMENT CHRE_BLE_EVENT_ID(1)
+
+/**
+ * nanoappHandleEvent argument: struct chreAsyncResult
+ *
+ * Indicates that a flush request made via chreBleFlushAsync() is complete, and
+ * all batched advertisements resulting from the flush have been delivered via
+ * preceding CHRE_EVENT_BLE_ADVERTISEMENT events.
+ *
+ * @since v1.7
+ */
+#define CHRE_EVENT_BLE_FLUSH_COMPLETE CHRE_BLE_EVENT_ID(2)
+
+/**
+ * nanoappHandleEvent argument: struct chreBleReadRssiEvent
+ *
+ * Provides the RSSI of an LE ACL connection following a call to
+ * chreBleReadRssiAsync().
+ *
+ * @since v1.8
+ */
+#define CHRE_EVENT_BLE_RSSI_READ CHRE_BLE_EVENT_ID(3)
+
+/**
+ * nanoappHandleEvent argument: struct chreBatchCompleteEvent
+ *
+ * This event is generated if the platform enabled batching, and when all
+ * events in a single batch has been delivered (for example, batching
+ * CHRE_EVENT_BLE_ADVERTISEMENT events if the platform has
+ * CHRE_BLE_CAPABILITIES_SCAN_RESULT_BATCHING enabled, and a non-zero
+ * reportDelayMs in chreBleStartScanAsync() was accepted).
+ *
+ * If the nanoapp receives a CHRE_EVENT_BLE_SCAN_STATUS_CHANGE with a non-zero
+ * reportDelayMs and enabled set to true, then this event must be generated.
+ *
+ * @since v1.8
+ */
+#define CHRE_EVENT_BLE_BATCH_COMPLETE CHRE_BLE_EVENT_ID(4)
+
+/**
+ * nanoappHandleEvent argument: struct chreBleScanStatus
+ *
+ * This event is generated when the values in chreBleScanStatus changes.
+ *
+ * @since v1.8
+ */
+#define CHRE_EVENT_BLE_SCAN_STATUS_CHANGE CHRE_BLE_EVENT_ID(5)
+
+// NOTE: Do not add new events with ID > 15
+/** @} */
+
+/**
+ * Maximum BLE (legacy) advertisement payload data length, in bytes
+ * This is calculated by subtracting 2 (type + len) from 31 (max payload).
+ */
+#define CHRE_BLE_DATA_LEN_MAX (29)
+
+/**
+ * BLE device address length, in bytes.
+ */
+#define CHRE_BLE_ADDRESS_LEN (6)
+
+/**
+ * RSSI value (int8_t) indicating no RSSI threshold.
+ */
+#define CHRE_BLE_RSSI_THRESHOLD_NONE (-128)
+
+/**
+ * RSSI value (int8_t) indicating no RSSI value available.
+ */
+#define CHRE_BLE_RSSI_NONE (127)
+
+/**
+ * Tx power value (int8_t) indicating no Tx power value available.
+ */
+#define CHRE_BLE_TX_POWER_NONE (127)
+
+/**
+ * Indicates ADI field was not provided in advertisement.
+ */
+#define CHRE_BLE_ADI_NONE (0xFF)
+
+/**
+ * The CHRE BLE advertising event type is based on the BT Core Spec v5.2,
+ * Vol 4, Part E, Section 7.7.65.13, LE Extended Advertising Report event,
+ * Event_Type.
+ *
+ * Note: helper functions are provided to avoid bugs, e.g. a nanoapp doing
+ * (eventTypeAndDataStatus == ADV_IND) instead of properly masking off reserved
+ * and irrelevant bits.
+ *
+ * @defgroup CHRE_BLE_EVENT
+ * @{
+ */
+// Extended event types
+#define CHRE_BLE_EVENT_MASK_TYPE (0x1f)
+#define CHRE_BLE_EVENT_TYPE_FLAG_CONNECTABLE (1 << 0)
+#define CHRE_BLE_EVENT_TYPE_FLAG_SCANNABLE (1 << 1)
+#define CHRE_BLE_EVENT_TYPE_FLAG_DIRECTED (1 << 2)
+#define CHRE_BLE_EVENT_TYPE_FLAG_SCAN_RSP (1 << 3)
+#define CHRE_BLE_EVENT_TYPE_FLAG_LEGACY (1 << 4)
+
+// Data status
+#define CHRE_BLE_EVENT_MASK_DATA_STATUS (0x3 << 5)
+#define CHRE_BLE_EVENT_DATA_STATUS_COMPLETE (0x0 << 5)
+#define CHRE_BLE_EVENT_DATA_STATUS_MORE_DATA_PENDING (0x1 << 5)
+#define CHRE_BLE_EVENT_DATA_STATUS_DATA_TRUNCATED (0x2 << 5)
+
+// Legacy event types
+#define CHRE_BLE_EVENT_TYPE_LEGACY_ADV_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_LEGACY | CHRE_BLE_EVENT_TYPE_FLAG_CONNECTABLE | \
+ CHRE_BLE_EVENT_TYPE_FLAG_SCANNABLE)
+#define CHRE_BLE_EVENT_TYPE_LEGACY_DIRECT_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_LEGACY | CHRE_BLE_EVENT_TYPE_FLAG_CONNECTABLE)
+#define CHRE_BLE_EVENT_TYPE_LEGACY_ADV_SCAN_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_LEGACY | CHRE_BLE_EVENT_TYPE_FLAG_SCANNABLE)
+#define CHRE_BLE_EVENT_TYPE_LEGACY_ADV_NONCONN_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_LEGACY)
+#define CHRE_BLE_EVENT_TYPE_LEGACY_SCAN_RESP_ADV_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_SCAN_RSP | CHRE_BLE_EVENT_TYPE_LEGACY_ADV_IND)
+#define CHRE_BLE_EVENT_TYPE_LEGACY_SCAN_RESP_ADV_SCAN_IND \
+ (CHRE_BLE_EVENT_TYPE_FLAG_SCAN_RSP | CHRE_BLE_EVENT_TYPE_LEGACY_ADV_SCAN_IND)
+/** @} */
+
+/**
+ * The maximum amount of time allowed to elapse between the call to
+ * chreBleFlushAsync() and when CHRE_EVENT_BLE_FLUSH_COMPLETE is delivered to
+ * the nanoapp on a successful flush.
+ */
+#define CHRE_BLE_FLUSH_COMPLETE_TIMEOUT_NS (5 * CHRE_NSEC_PER_SEC)
+
+/**
+ * Indicates a type of request made in this API. Used to populate the resultType
+ * field of struct chreAsyncResult sent with CHRE_EVENT_BLE_ASYNC_RESULT.
+ */
+enum chreBleRequestType {
+ CHRE_BLE_REQUEST_TYPE_START_SCAN = 1,
+ CHRE_BLE_REQUEST_TYPE_STOP_SCAN = 2,
+ CHRE_BLE_REQUEST_TYPE_FLUSH = 3, //!< @since v1.7
+ CHRE_BLE_REQUEST_TYPE_READ_RSSI = 4, //!< @since v1.8
+};
+
+/**
+ * CHRE BLE scan modes identify functional scan levels without specifying or
+ * guaranteeing particular scan parameters (e.g. duty cycle, interval, radio
+ * chain).
+ *
+ * The actual scan parameters may be platform dependent and may change without
+ * notice in real time based on contextual cues, etc.
+ *
+ * Scan modes should be selected based on use cases as described.
+ */
+enum chreBleScanMode {
+ //! A background scan level for always-running ambient applications.
+ //! A representative duty cycle may be between 3 - 10 % (tentative, and
+ //! with no guarantees).
+ CHRE_BLE_SCAN_MODE_BACKGROUND = 1,
+
+ //! A foreground scan level to be used for short periods.
+ //! A representative duty cycle may be between 10 - 20 % (tentative, and
+ //! with no guarantees).
+ CHRE_BLE_SCAN_MODE_FOREGROUND = 2,
+
+ //! A very high duty cycle scan level to be used for very short durations.
+ //! A representative duty cycle may be between 50 - 100 % (tentative, and
+ //! with no guarantees).
+ CHRE_BLE_SCAN_MODE_AGGRESSIVE = 3,
+};
+
+/**
+ * Selected AD Types are available among those defined in the Bluetooth spec.
+ * Assigned Numbers, Generic Access Profile.
+ * ref: https://www.bluetooth.com/specifications/assigned-numbers/
+ */
+enum chreBleAdType {
+ //! Service Data with 16-bit UUID
+ //! @since v1.8 CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16 was renamed
+ //! CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16_LE to reflect that nanoapps
+ //! compiled against v1.8+ should use OTA format for service data filters.
+ CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16_LE = 0x16,
+
+ //! Manufacturer Specific Data
+ //! @since v1.8
+ CHRE_BLE_AD_TYPE_MANUFACTURER_DATA = 0xff,
+};
+
+/**
+ * Generic filters are used to filter for the presence of AD structures in the
+ * data field of LE Extended Advertising Report events (ref: BT Core Spec v5.3,
+ * Vol 3, Part E, Section 11).
+ *
+ * The CHRE generic filter structure represents a generic filter on an AD Type
+ * as defined in the Bluetooth spec Assigned Numbers, Generic Access Profile
+ * (ref: https://www.bluetooth.com/specifications/assigned-numbers/). This
+ * generic structure is used by the Android HCI Advertising Packet Content
+ * Filter (APCF) AD Type sub-command 0x09 (ref:
+ * https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_apcf_command-ad_type_sub_cmd).
+ *
+ * The filter is matched when an advertisement event contains an AD structure in
+ * its data field that matches the following criteria:
+ * AdStructure.type == type
+ * AdStructure.data & dataMask == data & dataMask
+ *
+ * The maximum data length is limited to the maximum possible legacy
+ * advertisement payload data length (29 bytes). The data and dataMask must be
+ * in OTA format. For each zero bit of the dataMask, the corresponding
+ * data bit must also be zero.
+ *
+ * Note that the CHRE implementation may not support every kind of filter that
+ * can be represented by this structure. Use chreBleGetFilterCapabilities() to
+ * discover supported filtering capabilities at runtime.
+ *
+ * Example 1: To filter on a 16 bit service data UUID of 0xFE2C, the following
+ * settings would be used:
+ * type = CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16_LE
+ * len = 2
+ * data = {0x2C, 0xFE}
+ * dataMask = {0xFF, 0xFF}
+ *
+ * Example 2: To filter for manufacturer data of 0x12, 0x34 from Google (0x00E0),
+ * the following settings would be used:
+ * type = CHRE_BLE_AD_TYPE_MANUFACTURER_DATA
+ * len = 4
+ * data = {0xE0, 0x00, 0x12, 0x34}
+ * dataMask = {0xFF, 0xFF, 0xFF, 0xFF}
+ *
+ * Refer to "Supplement to the Bluetooth Core Specification for details (v9,
+ * Part A, Section 1.4)" for details regarding the manufacturer data format.
+ */
+struct chreBleGenericFilter {
+ //! Acceptable values among enum chreBleAdType
+ uint8_t type;
+
+ /**
+ * Length of data and dataMask. AD payloads shorter than this length will not
+ * be matched by the filter. Length must be greater than 0.
+ */
+ uint8_t len;
+
+ //! Used in combination with dataMask to filter an advertisement
+ uint8_t data[CHRE_BLE_DATA_LEN_MAX];
+
+ //! Used in combination with data to filter an advertisement
+ uint8_t dataMask[CHRE_BLE_DATA_LEN_MAX];
+};
+
+/**
+ * Broadcaster address filters are used to filter by the address field of the LE
+ * Extended Advertising Report event which is defined in the BT Core Spec v5.3,
+ * Vol 4, Part E, Section 7.7.65.13.
+ *
+ * The CHRE broadcaster address filter structure is modeled after the
+ * Advertising Packet Content Filter (APCF) HCI broadcaster address sub-command
+ * 0x02 (ref:
+ * https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_apcf_command-broadcast_address_sub_cmd).
+ * However, it differs from this HCI command in two major ways:
+ *
+ * 1) The CHRE broadcaster address filter does not filter by address type at
+ * this time. If a nanoapp wants to filter for a particular address type, it
+ * must check the addressType field of the chreBleAdvertisingReport.
+ *
+ * 2) The broadcasterAddress must be in big endian byte order to match the
+ * format of the Android Bluetooth API (ref:
+ * https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#getRemoteDevice(byte[])).
+ * This is intended to allow easier integration between nanoapp and Host
+ * code.
+ *
+ * The filter is matched when an advertisement even meets the following
+ * criteria:
+ * broadcasterAddress == chreBleAdvertisingReport.address.
+ *
+ * Example: To filter on the address (01:02:03:AB:CD:EF), the following
+ * settings would be used:
+ * broadcasterAddress = {0x01, 0x02, 0x03, 0xAB, 0xCD, 0xEF}
+ *
+ * @since v1.9
+ */
+struct chreBleBroadcasterAddressFilter {
+ //! 6-byte Broadcaster address
+ uint8_t broadcasterAddress[CHRE_BLE_ADDRESS_LEN];
+};
+
+/**
+ * CHRE Bluetooth LE scan filters.
+ *
+ * @see chreBleScanFilterV1_9 for further details.
+ *
+ * @deprecated as of v1.9 due to the addition of the
+ * chreBleBroadcasterAddressFilter. New code should use chreBleScanFilterV1_9
+ * instead of this struct. This struct will be removed in a future version.
+ */
+struct chreBleScanFilter {
+ //! RSSI threshold filter (Corresponding HCI OCF: 0x0157, Sub: 0x01), where
+ //! advertisements with RSSI values below this threshold may be disregarded.
+ //! An rssiThreshold value of CHRE_BLE_RSSI_THRESHOLD_NONE indicates no RSSI
+ //! filtering.
+ int8_t rssiThreshold;
+
+ //! Number of generic scan filters provided in the scanFilters array.
+ //! A scanFilterCount value of 0 indicates no generic scan filters.
+ uint8_t scanFilterCount;
+
+ //! Pointer to an array of scan filters. If the array contains more than one
+ //! entry, advertisements matching any of the entries will be returned
+ //! (functional OR).
+ const struct chreBleGenericFilter *scanFilters;
+};
+
+/**
+ * CHRE Bluetooth LE scan filters are based on a combination of an RSSI
+ * threshold, generic filters, and broadcaster address filters.
+ *
+ * When multiple filters are specified, rssiThreshold is combined with the other
+ * filters via functional AND, and the other filters are all combined as
+ * functional OR. In other words, an advertisement matches the filter if:
+ * rssi >= rssiThreshold
+ * AND (matchAny(genericFilters) OR matchAny(broadcasterAddressFilters))
+ *
+ * CHRE-provided filters are implemented in a best-effort manner, depending on
+ * HW capabilities of the system and available resources. Therefore, provided
+ * scan results may be a superset of the specified filters. Nanoapps should try
+ * to take advantage of CHRE scan filters as much as possible, but must design
+ * their logic as to not depend on CHRE filtering.
+ *
+ * The syntax of CHRE scan filter definition is modeled after a combination of
+ * multiple Android HCI Advertising Packet Content Filter (APCF) sub commands
+ * including the RSSI threshold from the set filtering parameters sub command
+ * (ref:
+ * https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_apcf_command-set_filtering_parameters_sub_cmd).
+ * @see chreBleGenericFilter and chreBleBroadcasterAddressFilter for details
+ * about other APCF sub commands referenced.
+ *
+ * @since v1.9
+ */
+struct chreBleScanFilterV1_9 {
+ //! RSSI threshold filter (Corresponding HCI OCF: 0x0157, Sub: 0x01), where
+ //! advertisements with RSSI values below this threshold may be disregarded.
+ //! An rssiThreshold value of CHRE_BLE_RSSI_THRESHOLD_NONE indicates no RSSI
+ //! filtering.
+ int8_t rssiThreshold;
+
+ //! Number of generic filters provided in the scanFilters array. A
+ //! genericFilterCount value of 0 indicates no generic filters.
+ uint8_t genericFilterCount;
+
+ //! Pointer to an array of generic filters. If the array contains more than
+ //! one entry, advertisements matching any of the entries will be returned
+ //! (functional OR). This is expected to be null if genericFilterCount is 0.
+ const struct chreBleGenericFilter *genericFilters;
+
+ //! Number of broadcaster address filters provided in the
+ //! broadcasterAddressFilters array. A broadcasterAddressFilterCount value
+ //! of 0 indicates no broadcaster address filters.
+ uint8_t broadcasterAddressFilterCount;
+
+ //! Pointer to an array of broadcaster address filters. If the array contains
+ //! more than one entry, advertisements matching any of the entries will be
+ //! returned (functional OR). This is expected to be null if
+ //! broadcasterAddressFilterCount is 0.
+ const struct chreBleBroadcasterAddressFilter *broadcasterAddressFilters;
+};
+
+/**
+ * CHRE BLE advertising address type is based on the BT Core Spec v5.2, Vol 4,
+ * Part E, Section 7.7.65.13, LE Extended Advertising Report event,
+ * Address_Type.
+ */
+enum chreBleAddressType {
+ //! Public device address.
+ CHRE_BLE_ADDRESS_TYPE_PUBLIC = 0x00,
+
+ //! Random device address.
+ CHRE_BLE_ADDRESS_TYPE_RANDOM = 0x01,
+
+ //! Public identity address (corresponds to resolved private address).
+ CHRE_BLE_ADDRESS_TYPE_PUBLIC_IDENTITY = 0x02,
+
+ //! Random (static) Identity Address (corresponds to resolved private
+ //! address)
+ CHRE_BLE_ADDRESS_TYPE_RANDOM_IDENTITY = 0x03,
+
+ //! No address provided (anonymous advertisement).
+ CHRE_BLE_ADDRESS_TYPE_NONE = 0xff,
+};
+
+/**
+ * CHRE BLE physical (PHY) channel encoding type, if supported, is based on the
+ * BT Core Spec v5.2, Vol 4, Part E, Section 7.7.65.13, LE Extended Advertising
+ * Report event, entries Primary_PHY and Secondary_PHY.
+ */
+enum chreBlePhyType {
+ //! No packets on this PHY (only on the secondary channel), or feature not
+ //! supported.
+ CHRE_BLE_PHY_NONE = 0x00,
+
+ //! LE 1 MBPS PHY encoding.
+ CHRE_BLE_PHY_1M = 0x01,
+
+ //! LE 2 MBPS PHY encoding (only on the secondary channel).
+ CHRE_BLE_PHY_2M = 0x02,
+
+ //! LE long-range coded PHY encoding.
+ CHRE_BLE_PHY_CODED = 0x03,
+};
+
+/**
+ * The CHRE BLE Advertising Report event is based on the BT Core Spec v5.2,
+ * Vol 4, Part E, Section 7.7.65.13, LE Extended Advertising Report event, with
+ * the following differences:
+ *
+ * 1) A CHRE timestamp field, which can be useful if CHRE is batching results.
+ * 2) Reordering of the rssi and periodicAdvertisingInterval fields for memory
+ * alignment (prevent padding).
+ * 3) Addition of four reserved bytes to reclaim padding.
+ * 4) The address fields are formatted in big endian byte order to match the
+ * order specified for BluetoothDevices in the Android Bluetooth API (ref:
+ * https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#getRemoteDevice(byte[])).
+ */
+struct chreBleAdvertisingReport {
+ //! The base timestamp, in nanoseconds, in the same time base as chreGetTime()
+ uint64_t timestamp;
+
+ //! @see CHRE_BLE_EVENT
+ uint8_t eventTypeAndDataStatus;
+
+ //! Advertising address type as defined in enum chreBleAddressType
+ uint8_t addressType;
+
+ //! Advertising device address. Formatted in big endian byte order.
+ uint8_t address[CHRE_BLE_ADDRESS_LEN];
+
+ //! Advertiser PHY on primary advertising physical channel, if supported, as
+ //! defined in enum chreBlePhyType.
+ uint8_t primaryPhy;
+
+ //! Advertiser PHY on secondary advertising physical channel, if supported, as
+ //! defined in enum chreBlePhyType.
+ uint8_t secondaryPhy;
+
+ //! Value of the Advertising SID subfield in the ADI field of the PDU among
+ //! the range of [0, 0x0f].
+ //! CHRE_BLE_ADI_NONE indicates no ADI field was provided.
+ //! Other values are reserved.
+ uint8_t advertisingSid;
+
+ //! Transmit (Tx) power in dBm. Typical values are [-127, 20].
+ //! CHRE_BLE_TX_POWER_NONE indicates Tx power not available.
+ int8_t txPower;
+
+ //! Interval of the periodic advertising in 1.25 ms intervals, i.e.
+ //! time = periodicAdvertisingInterval * 1.25 ms
+ //! 0 means no periodic advertising. Minimum value is otherwise 6 (7.5 ms).
+ uint16_t periodicAdvertisingInterval;
+
+ //! RSSI in dBm. Typical values are [-127, 20].
+ //! CHRE_BLE_RSSI_NONE indicates RSSI is not available.
+ int8_t rssi;
+
+ //! Direct address type (i.e. only accept connection requests from a known
+ //! peer device) as defined in enum chreBleAddressType.
+ uint8_t directAddressType;
+
+ //! Direct address (i.e. only accept connection requests from a known peer
+ //! device). Formatted in big endian byte order.
+ uint8_t directAddress[CHRE_BLE_ADDRESS_LEN];
+
+ //! Length of data field. Acceptable range is [0, 62] for legacy and
+ //! [0, 255] for extended advertisements.
+ uint16_t dataLength;
+
+ //! dataLength bytes of data, or null if dataLength is 0. This represents
+ //! the ADV_IND payload, optionally concatenated with SCAN_RSP, as indicated
+ //! by eventTypeAndDataStatus.
+ const uint8_t *data;
+
+ //! Reserved for future use; set to 0
+ uint32_t reserved;
+};
+
+/**
+ * A CHRE BLE Advertising Event can contain any number of CHRE BLE Advertising
+ * Reports (i.e. advertisements).
+ */
+struct chreBleAdvertisementEvent {
+ //! Reserved for future use; set to 0
+ uint16_t reserved;
+
+ //! Number of advertising reports in this event
+ uint16_t numReports;
+
+ //! Array of length numReports
+ const struct chreBleAdvertisingReport *reports;
+};
+
+/**
+ * The RSSI read on a particular LE connection handle, based on the parameters
+ * in BT Core Spec v5.3, Vol 4, Part E, Section 7.5.4, Read RSSI command
+ */
+struct chreBleReadRssiEvent {
+ //! Structure which contains the cookie associated with the original request,
+ //! along with an error code that indicates request success or failure.
+ struct chreAsyncResult result;
+
+ //! The handle upon which CHRE attempted to read RSSI.
+ uint16_t connectionHandle;
+
+ //! The RSSI of the last packet received on this connection, if valid
+ //! (-127 to 20)
+ int8_t rssi;
+};
+
+/**
+ * Describes the current status of the BLE request in the platform.
+ *
+ * @since v1.8
+ */
+struct chreBleScanStatus {
+ //! The currently configured report delay in the scan configuration.
+ //! If enabled is false, this value does not have meaning.
+ uint32_t reportDelayMs;
+
+ //! True if the BLE scan is currently enabled. This can be set to false
+ //! if BLE scan was temporarily disabled (e.g. BT subsystem is down,
+ //! or due to user settings).
+ bool enabled;
+
+ //! Reserved for future use - set to zero.
+ uint8_t reserved[3];
+};
+
+/**
+ * Retrieves a set of flags indicating the BLE features supported by the
+ * current CHRE implementation. The value returned by this function must be
+ * consistent for the entire duration of the nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_BLE_CAPABILITIES_* flags set. @see
+ * CHRE_BLE_CAPABILITIES
+ *
+ * @since v1.6
+ */
+uint32_t chreBleGetCapabilities(void);
+
+/**
+ * Retrieves a set of flags indicating the BLE filtering features supported by
+ * the current CHRE implementation. The value returned by this function must be
+ * consistent for the entire duration of the nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_BLE_FILTER_CAPABILITIES_* flags set.
+ * @see CHRE_BLE_FILTER_CAPABILITIES
+ *
+ * @since v1.6
+ */
+uint32_t chreBleGetFilterCapabilities(void);
+
+/**
+ * Helper function to extract event type from eventTypeAndDataStatus as defined
+ * in the BT Core Spec v5.2, Vol 4, Part E, Section 7.7.65.13, LE Extended
+ * Advertising Report event, entry Event_Type.
+ *
+ * @see CHRE_BLE_EVENT
+ *
+ * @param eventTypeAndDataStatus Combined event type and data status
+ *
+ * @return The event type portion of eventTypeAndDataStatus
+ */
+static inline uint8_t chreBleGetEventType(uint8_t eventTypeAndDataStatus) {
+ return (eventTypeAndDataStatus & CHRE_BLE_EVENT_MASK_TYPE);
+}
+
+/**
+ * Helper function to extract data status from eventTypeAndDataStatus as defined
+ * in the BT Core Spec v5.2, Vol 4, Part E, Section 7.7.65.13, LE Extended
+ * Advertising Report event, entry Event_Type.
+ *
+ * @see CHRE_BLE_EVENT
+ *
+ * @param eventTypeAndDataStatus Combined event type and data status
+ *
+ * @return The data status portion of eventTypeAndDataStatus
+ */
+static inline uint8_t chreBleGetDataStatus(uint8_t eventTypeAndDataStatus) {
+ return (eventTypeAndDataStatus & CHRE_BLE_EVENT_MASK_DATA_STATUS);
+}
+
+/**
+ * Helper function to to combine an event type with a data status to create
+ * eventTypeAndDataStatus as defined in the BT Core Spec v5.2, Vol 4, Part E,
+ * Section 7.7.65.13, LE Extended Advertising Report event, entry Event_Type.
+ *
+ * @see CHRE_BLE_EVENT
+ *
+ * @param eventType Event type
+ * @param dataStatus Data status
+ *
+ * @return A combined eventTypeAndDataStatus
+ */
+static inline uint8_t chreBleGetEventTypeAndDataStatus(uint8_t eventType,
+ uint8_t dataStatus) {
+ return ((eventType & CHRE_BLE_EVENT_MASK_TYPE) |
+ (dataStatus & CHRE_BLE_EVENT_MASK_DATA_STATUS));
+}
+
+/**
+ * Nanoapps must define CHRE_NANOAPP_USES_BLE somewhere in their build
+ * system (e.g. Makefile) if the nanoapp needs to use the following BLE APIs.
+ * In addition to allowing access to these APIs, defining this macro will also
+ * ensure CHRE enforces that all host clients this nanoapp talks to have the
+ * required Android permissions needed to access BLE functionality by adding
+ * metadata to the nanoapp.
+ */
+#if defined(CHRE_NANOAPP_USES_BLE) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+/**
+ * Start Bluetooth LE (BLE) scanning on CHRE.
+ *
+ * @see chreBleStartScanAsyncV1_9 for further details.
+ *
+ * @deprecated as of v1.9 due to the addition of the chreBleScanFilterV1_9
+ * struct and a cookie parameter. New code should use
+ * chreBleStartScanAsyncV1_9() instead of this function. This function will be
+ * removed in a future version.
+ */
+bool chreBleStartScanAsync(enum chreBleScanMode mode, uint32_t reportDelayMs,
+ const struct chreBleScanFilter *filter);
+
+/**
+ * Start Bluetooth LE (BLE) scanning on CHRE.
+ *
+ * The result of the operation will be delivered asynchronously via the CHRE
+ * event CHRE_EVENT_BLE_ASYNC_RESULT.
+ *
+ * The scan results will be delivered asynchronously via the CHRE event
+ * CHRE_EVENT_BLE_ADVERTISEMENT.
+ *
+ * If CHRE_USER_SETTING_BLE_AVAILABLE is disabled, CHRE is expected to return an
+ * async result with error CHRE_ERROR_FUNCTION_DISABLED. If this setting is
+ * enabled, the Bluetooth subsystem may still be powered down in the scenario
+ * where the main Bluetooth toggle is disabled, but the Bluetooth scanning
+ * setting is enabled, and there is no request for BLE to be enabled at the
+ * Android level. In this scenario, CHRE will return an async result with error
+ * CHRE_ERROR_FUNCTION_DISABLED.
+ *
+ * To ensure that Bluetooth remains powered on in this settings configuration so
+ * that a nanoapp can scan, the nanoapp's Android host entity should use the
+ * BluetoothAdapter.enableBLE() API to register this request with the Android
+ * Bluetooth stack.
+ *
+ * If chreBleStartScanAsync() is called while a previous scan has been started,
+ * the previous scan will be stopped first and replaced with the new scan.
+ *
+ * Note that some corresponding Android parameters are missing from the CHRE
+ * API, where the following default or typical parameters are used:
+ * Callback type: CALLBACK_TYPE_ALL_MATCHES
+ * Result type: SCAN_RESULT_TYPE_FULL
+ * Match mode: MATCH_MODE_AGGRESSIVE
+ * Number of matches per filter: MATCH_NUM_MAX_ADVERTISEMENT
+ * Legacy-only: false
+ * PHY type: PHY_LE_ALL_SUPPORTED
+ *
+ * A CHRE_EVENT_BLE_SCAN_STATUS_CHANGE will be generated if the values in
+ * chreBleScanStatus changes as a result of this call.
+ *
+ * @param mode Scanning mode selected among enum chreBleScanMode
+ * @param reportDelayMs Maximum requested batching delay in ms. 0 indicates no
+ * batching. Note that the system may deliver results
+ * before the maximum specified delay is reached.
+ * @param filter Pointer to the requested best-effort filter configuration as
+ * defined by struct chreBleScanFilter. The ownership of filter
+ * and its nested elements remains with the caller, and the caller
+ * may release it as soon as chreBleStartScanAsync() returns.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent as a response to this request.
+ *
+ * @return True to indicate that the request was accepted. False otherwise.
+ *
+ * @since v1.9
+ */
+bool chreBleStartScanAsyncV1_9(enum chreBleScanMode mode,
+ uint32_t reportDelayMs,
+ const struct chreBleScanFilterV1_9 *filter,
+ const void *cookie);
+
+/**
+ * Stops a CHRE BLE scan.
+ *
+ * @see chreBleStopScanAsyncV1_9 for further details.
+ *
+ * @deprecated as of v1.9 due to the addition of the cookie parameter. New code
+ * should use chreBleStopScanAsyncV1_9() instead of this function. This function
+ * will be removed in a future version.
+ */
+bool chreBleStopScanAsync(void);
+
+/**
+ * Stops a CHRE BLE scan.
+ *
+ * The result of the operation will be delivered asynchronously via the CHRE
+ * event CHRE_EVENT_BLE_ASYNC_RESULT.
+ *
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent as a response to this request.
+ *
+ * @return True to indicate that the request was accepted. False otherwise.
+ *
+ * @since v1.9
+ */
+bool chreBleStopScanAsyncV1_9(const void *cookie);
+
+/**
+ * Requests to immediately deliver batched scan results. The nanoapp must
+ * have an active BLE scan request. If a request is accepted, it will be treated
+ * as though the reportDelayMs has expired for a batched scan. Upon accepting
+ * the request, CHRE works to immediately deliver scan results currently kept in
+ * batching memory, if any, via regular CHRE_EVENT_BLE_ADVERTISEMENT events,
+ * followed by a CHRE_EVENT_BLE_FLUSH_COMPLETE event.
+ *
+ * If the underlying system fails to complete the flush operation within
+ * CHRE_BLE_FLUSH_COMPLETE_TIMEOUT_NS, CHRE will send a
+ * CHRE_EVENT_BLE_FLUSH_COMPLETE event with CHRE_ERROR_TIMEOUT.
+ *
+ * If multiple flush requests are made prior to flush completion, then the
+ * requesting nanoapp will receive all batched samples existing at the time of
+ * the latest flush request. In this case, the number of
+ * CHRE_EVENT_BLE_FLUSH_COMPLETE events received must equal the number of flush
+ * requests made.
+ *
+ * If chreBleStopScanAsync() is called while a flush operation is in progress,
+ * it is unspecified whether the flush operation will complete successfully or
+ * return an error, such as CHRE_ERROR_FUNCTION_DISABLED, but in any case,
+ * CHRE_EVENT_BLE_FLUSH_COMPLETE must still be delivered. The same applies if
+ * the Bluetooth user setting is disabled during a flush operation.
+ *
+ * If called while running on a CHRE API version below v1.7, this function
+ * returns false and has no effect.
+ *
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent as a response to this request.
+ *
+ * @return True to indicate the request was accepted. False otherwise.
+ *
+ * @since v1.7
+ */
+bool chreBleFlushAsync(const void *cookie);
+
+/**
+ * Requests to read the RSSI of a peer device on the given LE connection
+ * handle.
+ *
+ * If the request is accepted, the response will be delivered in a
+ * CHRE_EVENT_BLE_RSSI_READ event with the same cookie.
+ *
+ * The request may be rejected if resources are not available to service the
+ * request (such as if too many outstanding requests already exist). If so, the
+ * client may retry later.
+ *
+ * Note that the connectionHandle is valid only while the connection remains
+ * active. If a peer device disconnects then reconnects, the handle may change.
+ * BluetoothDevice#getConnectionHandle() can be used from the Android framework
+ * to get the latest handle upon reconnection.
+ *
+ * @param connectionHandle
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * embedded in the response to this request.
+ * @return True if the request has been accepted and dispatched to the
+ * controller. False otherwise.
+ *
+ * @since v1.8
+ *
+ */
+bool chreBleReadRssiAsync(uint16_t connectionHandle, const void *cookie);
+
+/**
+ * Retrieves the current state of the BLE scan on the platform.
+ *
+ * @param status A non-null pointer to where the scan status will be
+ * populated.
+ *
+ * @return True if the status was obtained successfully.
+ *
+ * @since v1.8
+ */
+bool chreBleGetScanStatus(struct chreBleScanStatus *status);
+
+/**
+ * Definitions for handling unsupported CHRE BLE scenarios.
+ */
+#else // defined(CHRE_NANOAPP_USES_BLE) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+#define CHRE_BLE_PERM_ERROR_STRING \
+ "CHRE_NANOAPP_USES_BLE must be defined when building this nanoapp in " \
+ "order to refer to "
+
+#define chreBleStartScanAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleStartScanAsync")
+
+#define chreBleStopScanAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleStopScanAsync")
+
+#define chreBleFlushAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleFlushAsync")
+
+#define chreBleReadRssiAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_BLE_PERM_ERROR_STRING "chreBleReadRssiAsync")
+
+#endif // defined(CHRE_NANOAPP_USES_BLE) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CHRE_BLE_H_ */
diff --git a/chre_api/legacy/v1_10/chre/common.h b/chre_api/legacy/v1_10/chre/common.h
new file mode 100644
index 0000000..beecc46
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/common.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_COMMON_H_
+#define _CHRE_COMMON_H_
+
+/**
+ * @file
+ * Definitions shared across multiple CHRE header files
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Mask of the 5 most significant bytes in a 64-bit nanoapp or CHRE platform
+ * identifier, which represents the vendor ID portion of the ID.
+ */
+#define CHRE_VENDOR_ID_MASK UINT64_C(0xFFFFFFFFFF000000)
+
+/**
+ * Vendor ID "Googl". Used in nanoapp IDs and CHRE platform IDs developed and
+ * released by Google.
+ */
+#define CHRE_VENDOR_ID_GOOGLE UINT64_C(0x476F6F676C000000)
+
+/**
+ * Vendor ID "GoogT". Used for nanoapp IDs associated with testing done by
+ * Google.
+ */
+#define CHRE_VENDOR_ID_GOOGLE_TEST UINT64_C(0x476F6F6754000000)
+
+/**
+ * Helper macro to mask off all bytes other than the vendor ID (most significant
+ * 5 bytes) in 64-bit nanoapp and CHRE platform identifiers.
+ *
+ * @see chreGetNanoappInfo()
+ * @see chreGetPlatformId()
+ */
+#define CHRE_EXTRACT_VENDOR_ID(id) ((id) & CHRE_VENDOR_ID_MASK)
+
+/**
+ * Number of nanoseconds in one second, represented as an unsigned 64-bit
+ * integer
+ */
+#define CHRE_NSEC_PER_SEC UINT64_C(1000000000)
+
+/**
+ * General timeout for asynchronous API requests. Unless specified otherwise, a
+ * function call that returns data asynchronously via an event, such as
+ * CHRE_EVENT_ASYNC_GNSS_RESULT, must do so within this amount of time.
+ */
+#define CHRE_ASYNC_RESULT_TIMEOUT_NS (5 * CHRE_NSEC_PER_SEC)
+
+/**
+ * A generic listing of error codes for use in {@link #chreAsyncResult} and
+ * elsewhere. In general, module-specific error codes may be added to this enum,
+ * but effort should be made to come up with a generic name that still captures
+ * the meaning of the error.
+ */
+// LINT.IfChange
+enum chreError {
+ //! No error occurred
+ CHRE_ERROR_NONE = 0,
+
+ //! An unspecified failure occurred
+ CHRE_ERROR = 1,
+
+ //! One or more supplied arguments are invalid
+ CHRE_ERROR_INVALID_ARGUMENT = 2,
+
+ //! Unable to satisfy request because the system is busy
+ CHRE_ERROR_BUSY = 3,
+
+ //! Unable to allocate memory
+ CHRE_ERROR_NO_MEMORY = 4,
+
+ //! The requested feature is not supported
+ CHRE_ERROR_NOT_SUPPORTED = 5,
+
+ //! A timeout occurred while processing the request
+ CHRE_ERROR_TIMEOUT = 6,
+
+ //! The relevant capability is disabled, for example due to a user
+ //! configuration that takes precedence over this request
+ CHRE_ERROR_FUNCTION_DISABLED = 7,
+
+ //! The request was rejected due to internal rate limiting of the requested
+ //! functionality - the client may try its request again after waiting an
+ //! unspecified amount of time
+ CHRE_ERROR_REJECTED_RATE_LIMIT = 8,
+
+ //! The requested functionality is not currently accessible from the CHRE,
+ //! because another client, such as the main applications processor, is
+ //! currently controlling it.
+ CHRE_ERROR_FUNCTION_RESTRICTED_TO_OTHER_MASTER = 9,
+ CHRE_ERROR_FUNCTION_RESTRICTED_TO_OTHER_CLIENT = 9,
+
+ //! This request is no longer valid. It may have been replaced by a newer
+ //! request before taking effect.
+ //! @since v1.6
+ CHRE_ERROR_OBSOLETE_REQUEST = 10,
+
+ //! A transient error occurred. The request can be retried.
+ //! @since v1.10
+ CHRE_ERROR_TRANSIENT = 11,
+
+ //! Unable to satisfy request because of missing permissions.
+ //! @since v1.10
+ CHRE_ERROR_PERMISSION_DENIED = 12,
+
+ //! Unable to satisfy request because the destination is not found.
+ //! @since v1.10
+ CHRE_ERROR_DESTINATION_NOT_FOUND = 13,
+
+ //!< Do not exceed this value when adding new error codes
+ CHRE_ERROR_LAST = UINT8_MAX,
+};
+// LINT.ThenChange(../../../../core/include/chre/core/api_manager_common.h)
+
+/**
+ * Generic data structure to indicate the result of an asynchronous operation.
+ *
+ * @note
+ * The general model followed by CHRE for asynchronous operations is that a
+ * request function returns a boolean value that indicates whether the request
+ * was accepted for further processing. The actual result of the operation is
+ * provided in a subsequent event sent with an event type that is defined in the
+ * specific API. Typically, a "cookie" parameter is supplied to allow the client
+ * to tie the response to a specific request, or pass data through, etc. The
+ * response is expected to be delivered within CHRE_ASYNC_RESULT_TIMEOUT_NS if
+ * not specified otherwise.
+ *
+ * The CHRE implementation must allow for multiple asynchronous requests to be
+ * outstanding at a given time, under reasonable resource constraints. Further,
+ * requests must be processed in the same order as supplied by the client of the
+ * API in order to maintain causality. Using GNSS as an example, if a client
+ * calls chreGnssLocationSessionStartAsync() and then immediately calls
+ * chreGnssLocationSessionStopAsync(), the final result must be that the
+ * location session is stopped. Whether requests always complete in the
+ * order that they are given is implementation-defined. For example, if a client
+ * calls chreGnssLocationSessionStart() and then immediately calls
+ * chreGnssMeasurementSessionStart(), it is possible for the
+ * CHRE_EVENT_GNSS_RESULT associated with the measurement session to be
+ * delivered before the one for the location session.
+ */
+struct chreAsyncResult {
+ //! Indicates the request associated with this result. The interpretation of
+ //! values in this field is dependent upon the event type provided when this
+ //! result was delivered.
+ uint8_t requestType;
+
+ //! Set to true if the request was successfully processed
+ bool success;
+
+ //! If the request failed (success is false), this is set to a value from
+ //! enum chreError (other than CHRE_ERROR_NONE), which may provide
+ //! additional information about the nature of the failure.
+ //! @see #chreError
+ uint8_t errorCode;
+
+ //! Reserved for future use, set to 0
+ uint8_t reserved;
+
+ //! Set to the cookie parameter given to the request function tied to this
+ //! result
+ const void *cookie;
+};
+
+/**
+ * A structure to store an event describing the end of batched events.
+ *
+ * @since v1.8
+ */
+struct chreBatchCompleteEvent {
+ //! Indicates the type of event (of type CHRE_EVENT_TYPE_*) that was
+ //! batched.
+ uint16_t eventType;
+
+ //! Reserved for future use, set to 0
+ uint8_t reserved[2];
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_COMMON_H_ */
diff --git a/chre_api/legacy/v1_10/chre/event.h b/chre_api/legacy/v1_10/chre/event.h
new file mode 100644
index 0000000..d08b7d0
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/event.h
@@ -0,0 +1,1044 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_EVENT_H_
+#define _CHRE_EVENT_H_
+
+/**
+ * @file
+ * Context Hub Runtime Environment API dealing with events and messages.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <chre/toolchain.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The CHRE implementation is required to provide the following preprocessor
+ * defines via the build system.
+ *
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE: The maximum size, in bytes, allowed for
+ * a message sent to chreSendMessageToHostEndpoint(). This must be at least
+ * CHRE_MESSAGE_TO_HOST_MINIMUM_MAX_SIZE. If the system supports a larger
+ * maximum size, it will be defined as the return value of
+ * chreGetMessageToHostMaxSize().
+ */
+#ifndef CHRE_MESSAGE_TO_HOST_MAX_SIZE
+#error CHRE_MESSAGE_TO_HOST_MAX_SIZE must be defined by the CHRE implementation
+#endif
+
+/**
+ * The minimum size, in bytes, any CHRE implementation will use for
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE is set to 1000 for v1.5+ CHRE implementations,
+ * and 128 for v1.0-v1.4 implementations (previously kept in
+ * CHRE_MESSAGE_TO_HOST_MINIMUM_MAX_SIZE, which has been removed).
+ *
+ * All CHRE implementations supporting v1.5+ must support the raised limit of
+ * 1000 bytes, however a nanoapp compiled against v1.5 cannot assume this
+ * limit if there is a possibility their binary will run on a v1.4 or earlier
+ * implementation that had a lower limit. To allow for nanoapp compilation in
+ * these situations, CHRE_MESSAGE_TO_HOST_MAX_SIZE must be set to the minimum
+ * value the nanoapp may encounter, and CHRE_NANOAPP_SUPPORTS_PRE_V1_5 can be
+ * defined to skip the compile-time check.
+ */
+#if (!defined(CHRE_NANOAPP_SUPPORTS_PRE_V1_5) && \
+ CHRE_MESSAGE_TO_HOST_MAX_SIZE < 1000) || \
+ (defined(CHRE_NANOAPP_SUPPORTS_PRE_V1_5) && \
+ CHRE_MESSAGE_TO_HOST_MAX_SIZE < 128)
+#error CHRE_MESSAGE_TO_HOST_MAX_SIZE is too small.
+#endif
+
+/**
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE must be less than or equal to 4096. If the system
+ * supports a larger maximum size, it will be defined as the return value of
+ * chreGetMessageToHostMaxSize().
+ */
+#if CHRE_MESSAGE_TO_HOST_MAX_SIZE > 4096
+#error CHRE_MESSAGE_TO_HOST_MAX_SIZE must be <= 4096
+#endif
+
+/**
+ * The lowest numerical value legal for a user-defined event.
+ *
+ * The system reserves all event values from 0 to 0x7FFF, inclusive.
+ * User events may use any value in the range 0x8000 to 0xFFFF, inclusive.
+ *
+ * Note that the same event values might be used by different nanoapps
+ * for different meanings. This is not a concern, as these values only
+ * have meaning when paired with the originating nanoapp.
+ */
+#define CHRE_EVENT_FIRST_USER_VALUE UINT16_C(0x8000)
+
+/**
+ * nanoappHandleEvent argument: struct chreMessageFromHostData
+ *
+ * The format of the 'message' part of this structure is left undefined,
+ * and it's up to the nanoapp and host to have an established protocol
+ * beforehand.
+ */
+#define CHRE_EVENT_MESSAGE_FROM_HOST UINT16_C(0x0001)
+
+/**
+ * nanoappHandleEvent argument: 'cookie' given to chreTimerSet() method.
+ *
+ * Indicates that a timer has elapsed, in accordance with how chreTimerSet() was
+ * invoked.
+ */
+#define CHRE_EVENT_TIMER UINT16_C(0x0002)
+
+/**
+ * nanoappHandleEvent argument: struct chreNanoappInfo
+ *
+ * Indicates that a nanoapp has successfully started (its nanoappStart()
+ * function has been called, and it returned true) and is able to receive events
+ * sent via chreSendEvent(). Note that this event is not sent for nanoapps that
+ * were started prior to the current nanoapp - use chreGetNanoappInfo() to
+ * determine if another nanoapp is already running.
+ *
+ * @see chreConfigureNanoappInfoEvents
+ * @since v1.1
+ */
+#define CHRE_EVENT_NANOAPP_STARTED UINT16_C(0x0003)
+
+/**
+ * nanoappHandleEvent argument: struct chreNanoappInfo
+ *
+ * Indicates that a nanoapp has stopped executing and is no longer able to
+ * receive events sent via chreSendEvent(). Any events sent prior to receiving
+ * this event are not guaranteed to have been delivered.
+ *
+ * @see chreConfigureNanoappInfoEvents
+ * @since v1.1
+ */
+#define CHRE_EVENT_NANOAPP_STOPPED UINT16_C(0x0004)
+
+/**
+ * nanoappHandleEvent argument: NULL
+ *
+ * Indicates that CHRE has observed the host wake from low-power sleep state.
+ *
+ * @see chreConfigureHostSleepStateEvents
+ * @since v1.2
+ */
+#define CHRE_EVENT_HOST_AWAKE UINT16_C(0x0005)
+
+/**
+ * nanoappHandleEvent argument: NULL
+ *
+ * Indicates that CHRE has observed the host enter low-power sleep state.
+ *
+ * @see chreConfigureHostSleepStateEvents
+ * @since v1.2
+ */
+#define CHRE_EVENT_HOST_ASLEEP UINT16_C(0x0006)
+
+/**
+ * nanoappHandleEvent argument: NULL
+ *
+ * Indicates that CHRE is collecting debug dumps. Nanoapps can call
+ * chreDebugDumpLog() to log their debug data while handling this event.
+ *
+ * @see chreConfigureDebugDumpEvent
+ * @see chreDebugDumpLog
+ * @since v1.4
+ */
+#define CHRE_EVENT_DEBUG_DUMP UINT16_C(0x0007)
+
+/**
+ * nanoappHandleEvent argument: struct chreHostEndpointNotification
+ *
+ * Notifications event regarding a host endpoint.
+ *
+ * @see chreConfigureHostEndpointNotifications
+ * @since v1.6
+ */
+#define CHRE_EVENT_HOST_ENDPOINT_NOTIFICATION UINT16_C(0x0008)
+
+/**
+ * Indicates a RPC request from a nanoapp.
+ *
+ * @since v1.9
+ */
+#define CHRE_EVENT_RPC_REQUEST UINT16_C(0x00009)
+
+/**
+ * Indicates a RPC response from a nanoapp.
+ *
+ * @since v1.9
+ */
+#define CHRE_EVENT_RPC_RESPONSE UINT16_C(0x0000A)
+
+/**
+ * nanoappHandleEvent argument: struct chreAsyncResult
+ *
+ * Async status for reliable messages. The resultType field
+ * will be populated with a value of 0.
+ *
+ * @see chreSendReliableMessageAsync
+ * @since v1.10
+ */
+#define CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT UINT16_C(0x000B)
+
+/**
+ * First possible value for CHRE_EVENT_SENSOR events.
+ *
+ * This allows us to separately define our CHRE_EVENT_SENSOR_* events in
+ * chre/sensor.h, without fear of collision with other event values.
+ */
+#define CHRE_EVENT_SENSOR_FIRST_EVENT UINT16_C(0x0100)
+
+/**
+ * Last possible value for CHRE_EVENT_SENSOR events.
+ *
+ * This allows us to separately define our CHRE_EVENT_SENSOR_* events in
+ * chre/sensor.h, without fear of collision with other event values.
+ */
+#define CHRE_EVENT_SENSOR_LAST_EVENT UINT16_C(0x02FF)
+
+/**
+ * First event in the block reserved for GNSS. These events are defined in
+ * chre/gnss.h.
+ */
+#define CHRE_EVENT_GNSS_FIRST_EVENT UINT16_C(0x0300)
+#define CHRE_EVENT_GNSS_LAST_EVENT UINT16_C(0x030F)
+
+/**
+ * First event in the block reserved for WiFi. These events are defined in
+ * chre/wifi.h.
+ */
+#define CHRE_EVENT_WIFI_FIRST_EVENT UINT16_C(0x0310)
+#define CHRE_EVENT_WIFI_LAST_EVENT UINT16_C(0x031F)
+
+/**
+ * First event in the block reserved for WWAN. These events are defined in
+ * chre/wwan.h.
+ */
+#define CHRE_EVENT_WWAN_FIRST_EVENT UINT16_C(0x0320)
+#define CHRE_EVENT_WWAN_LAST_EVENT UINT16_C(0x032F)
+
+/**
+ * First event in the block reserved for audio. These events are defined in
+ * chre/audio.h.
+ */
+#define CHRE_EVENT_AUDIO_FIRST_EVENT UINT16_C(0x0330)
+#define CHRE_EVENT_AUDIO_LAST_EVENT UINT16_C(0x033F)
+
+/**
+ * First event in the block reserved for settings changed notifications.
+ * These events are defined in chre/user_settings.h
+ *
+ * @since v1.5
+ */
+#define CHRE_EVENT_SETTING_CHANGED_FIRST_EVENT UINT16_C(0x340)
+#define CHRE_EVENT_SETTING_CHANGED_LAST_EVENT UINT16_C(0x34F)
+
+/**
+ * First event in the block reserved for Bluetooth LE. These events are defined
+ * in chre/ble.h.
+ */
+#define CHRE_EVENT_BLE_FIRST_EVENT UINT16_C(0x0350)
+#define CHRE_EVENT_BLE_LAST_EVENT UINT16_C(0x035F)
+
+/**
+ * First in the extended range of values dedicated for internal CHRE
+ * implementation usage.
+ *
+ * This range is semantically the same as the internal event range defined
+ * below, but has been extended to allow for more implementation-specific events
+ * to be used.
+ *
+ * @since v1.1
+ */
+#define CHRE_EVENT_INTERNAL_EXTENDED_FIRST_EVENT UINT16_C(0x7000)
+
+/**
+ * First in a range of values dedicated for internal CHRE implementation usage.
+ *
+ * If a CHRE wishes to use events internally, any values within this range
+ * are assured not to be taken by future CHRE API additions.
+ */
+#define CHRE_EVENT_INTERNAL_FIRST_EVENT UINT16_C(0x7E00)
+
+/**
+ * Last in a range of values dedicated for internal CHRE implementation usage.
+ *
+ * If a CHRE wishes to use events internally, any values within this range
+ * are assured not to be taken by future CHRE API additions.
+ */
+#define CHRE_EVENT_INTERNAL_LAST_EVENT UINT16_C(0x7FFF)
+
+/**
+ * A special value for the hostEndpoint argument in
+ * chreSendMessageToHostEndpoint() that indicates that the message should be
+ * delivered to all host endpoints. This value will not be used in the
+ * hostEndpoint field of struct chreMessageFromHostData supplied with
+ * CHRE_EVENT_MESSAGE_FROM_HOST.
+ *
+ * @since v1.1
+ */
+#define CHRE_HOST_ENDPOINT_BROADCAST UINT16_C(0xFFFF)
+
+/**
+ * A special value for hostEndpoint in struct chreMessageFromHostData that
+ * indicates that a host endpoint is unknown or otherwise unspecified. This
+ * value may be received in CHRE_EVENT_MESSAGE_FROM_HOST, but it is not valid to
+ * provide it to chreSendMessageToHostEndpoint().
+ *
+ * @since v1.1
+ */
+#define CHRE_HOST_ENDPOINT_UNSPECIFIED UINT16_C(0xFFFE)
+
+/**
+ * Bitmask values that can be given as input to the messagePermissions parameter
+ * of chreSendMessageWithPermissions(). These values are typically used by
+ * nanoapps when they used data from the corresponding CHRE APIs to produce the
+ * message contents being sent and is used to attribute permissions usage on
+ * the Android side. See chreSendMessageWithPermissions() for more details on
+ * how these values are used when sending a message.
+ *
+ * Values in the range
+ * [CHRE_MESSAGE_PERMISSION_VENDOR_START, CHRE_MESSAGE_PERMISSION_VENDOR_END]
+ * are reserved for vendors to use when adding support for permission-gated APIs
+ * in their implementations.
+ *
+ * On the Android side, CHRE permissions are mapped as follows:
+ * - CHRE_MESSAGE_PERMISSION_AUDIO: android.permission.RECORD_AUDIO
+ * - CHRE_MESSAGE_PERMISSION_GNSS, CHRE_MESSAGE_PERMISSION_WIFI, and
+ * CHRE_MESSAGE_PERMISSION_WWAN: android.permission.ACCESS_FINE_LOCATION, and
+ * android.permissions.ACCESS_BACKGROUND_LOCATION
+ *
+ * @since v1.5
+ *
+ * @defgroup CHRE_MESSAGE_PERMISSION
+ * @{
+ */
+
+#define CHRE_MESSAGE_PERMISSION_NONE UINT32_C(0)
+#define CHRE_MESSAGE_PERMISSION_AUDIO UINT32_C(1)
+#define CHRE_MESSAGE_PERMISSION_GNSS (UINT32_C(1) << 1)
+#define CHRE_MESSAGE_PERMISSION_WIFI (UINT32_C(1) << 2)
+#define CHRE_MESSAGE_PERMISSION_WWAN (UINT32_C(1) << 3)
+#define CHRE_MESSAGE_PERMISSION_BLE (UINT32_C(1) << 4)
+#define CHRE_MESSAGE_PERMISSION_VENDOR_START (UINT32_C(1) << 24)
+#define CHRE_MESSAGE_PERMISSION_VENDOR_END (UINT32_C(1) << 31)
+
+/** @} */
+
+/**
+ * Reserved message type for RPC messages.
+ *
+ * @see chreSendMessageWithPermissions
+ *
+ * @since v1.9
+ */
+#define CHRE_MESSAGE_TYPE_RPC UINT32_C(0x7FFFFFF5)
+
+/**
+ * @see chrePublishRpcServices
+ *
+ * @since v1.8
+ */
+#define CHRE_MINIMUM_RPC_SERVICE_LIMIT UINT8_C(4)
+
+/**
+ * Data provided with CHRE_EVENT_MESSAGE_FROM_HOST.
+ */
+struct chreMessageFromHostData {
+ /**
+ * Message type supplied by the host.
+ *
+ * @note In CHRE API v1.0, support for forwarding this field from the host
+ * was not strictly required, and some implementations did not support it.
+ * However, its support is mandatory as of v1.1.
+ */
+ union {
+ /**
+ * The preferred name to use when referencing this field.
+ *
+ * @since v1.1
+ */
+ uint32_t messageType;
+
+ /**
+ * @deprecated This is the name for the messageType field used in v1.0.
+ * Left to allow code to compile against both v1.0 and v1.1 of the API
+ * definition without needing to use #ifdefs. This will be removed in a
+ * future API update - use messageType instead.
+ */
+ uint32_t reservedMessageType;
+ };
+
+ /**
+ * The size, in bytes of the following 'message'.
+ *
+ * This can be 0.
+ */
+ uint32_t messageSize;
+
+ /**
+ * The message from the host.
+ *
+ * These contents are of a format that the host and nanoapp must have
+ * established beforehand.
+ *
+ * This data is 'messageSize' bytes in length. Note that if 'messageSize'
+ * is 0, this might be NULL.
+ */
+ const void *message;
+
+ /**
+ * An identifier for the host-side entity that sent this message. Unless
+ * this is set to CHRE_HOST_ENDPOINT_UNSPECIFIED, it can be used in
+ * chreSendMessageToHostEndpoint() to send a directed reply that will only
+ * be received by the given entity on the host. Endpoint identifiers are
+ * opaque values assigned at runtime, so they cannot be assumed to always
+ * describe a specific entity across restarts.
+ *
+ * If running on a CHRE API v1.0 implementation, this field will always be
+ * set to CHRE_HOST_ENDPOINT_UNSPECIFIED.
+ *
+ * @since v1.1
+ */
+ uint16_t hostEndpoint;
+};
+
+/**
+ * Provides metadata for a nanoapp in the system.
+ */
+struct chreNanoappInfo {
+ /**
+ * Nanoapp identifier. The convention for populating this value is to set
+ * the most significant 5 bytes to a value that uniquely identifies the
+ * vendor, and the lower 3 bytes identify the nanoapp.
+ */
+ uint64_t appId;
+
+ /**
+ * Nanoapp version. The semantics of this field are defined by the nanoapp,
+ * however nanoapps are recommended to follow the same scheme used for the
+ * CHRE version exposed in chreGetVersion(). That is, the most significant
+ * byte represents the major version, the next byte the minor version, and
+ * the lower two bytes the patch version.
+ */
+ uint32_t version;
+
+ /**
+ * The instance ID of this nanoapp, which can be used in chreSendEvent() to
+ * address an event specifically to this nanoapp. This identifier is
+ * guaranteed to be unique among all nanoapps in the system.
+ *
+ * As of CHRE API v1.6, instance ID is guaranteed to never be greater than
+ * UINT16_MAX. This allows for the instance ID be packed with other data
+ * inside a 32-bit integer (useful for RPC routing).
+ */
+ uint32_t instanceId;
+
+ /**
+ * Reserved for future use.
+ * Always set to 0.
+ */
+ uint8_t reserved[3];
+
+ /**
+ * The number of RPC services exposed by this nanoapp.
+ * The service details are available in the rpcServices array.
+ * Must always be set to 0 when running on a CHRE implementation prior to
+ * v1.8
+ *
+ * @since v1.8
+ */
+ uint8_t rpcServiceCount;
+
+ /*
+ * Array of RPC services published by this nanoapp.
+ * Services are published via chrePublishRpcServices.
+ * The array contains rpcServiceCount entries.
+ *
+ * The pointer is only valid when rpcServiceCount is greater than 0.
+ *
+ * @since v1.8
+ */
+ const struct chreNanoappRpcService *rpcServices;
+};
+
+/**
+ * The types of notification events that can be included in struct
+ * chreHostEndpointNotification.
+ *
+ * @defgroup HOST_ENDPOINT_NOTIFICATION_TYPE
+ * @{
+ */
+#define HOST_ENDPOINT_NOTIFICATION_TYPE_DISCONNECT UINT8_C(0)
+/** @} */
+
+/**
+ * Data provided in CHRE_EVENT_HOST_ENDPOINT_NOTIFICATION.
+ */
+struct chreHostEndpointNotification {
+ /**
+ * The ID of the host endpoint that this notification is for.
+ */
+ uint16_t hostEndpointId;
+
+ /**
+ * The type of notification this event represents, which should be
+ * one of the HOST_ENDPOINT_NOTIFICATION_TYPE_* values.
+ */
+ uint8_t notificationType;
+
+ /**
+ * Reserved for future use, must be zero.
+ */
+ uint8_t reserved;
+};
+
+//! The maximum length of a host endpoint's name.
+#define CHRE_MAX_ENDPOINT_NAME_LEN (51)
+
+//! The maximum length of a host endpoint's tag.
+#define CHRE_MAX_ENDPOINT_TAG_LEN (51)
+
+/**
+ * The type of host endpoint that can be used in the hostEndpointType field
+ * of chreHostEndpointInfo.
+ *
+ * @since v1.6
+ *
+ * @defgroup CHRE_HOST_ENDPOINT_TYPE_
+ * @{
+ */
+
+//! The host endpoint is part of the Android system framework.
+#define CHRE_HOST_ENDPOINT_TYPE_FRAMEWORK UINT8_C(0x00)
+
+//! The host endpoint is an Android app.
+#define CHRE_HOST_ENDPOINT_TYPE_APP UINT8_C(0x01)
+
+//! The host endpoint is an Android native program.
+#define CHRE_HOST_ENDPOINT_TYPE_NATIVE UINT8_C(0x02)
+
+//! Values in the range [CHRE_HOST_ENDPOINT_TYPE_VENDOR_START,
+//! CHRE_HOST_ENDPOINT_TYPE_VENDOR_END] can be a custom defined host endpoint
+//! type for platform-specific vendor use.
+#define CHRE_HOST_ENDPOINT_TYPE_VENDOR_START UINT8_C(0x80)
+#define CHRE_HOST_ENDPOINT_TYPE_VENDOR_END UINT8_C(0xFF)
+
+/** @} */
+
+/**
+ * Provides metadata for a host endpoint.
+ *
+ * @since v1.6
+ */
+struct chreHostEndpointInfo {
+ //! The endpoint ID of this host.
+ uint16_t hostEndpointId;
+
+ //! The type of host endpoint, which must be set to one of the
+ //! CHRE_HOST_ENDPOINT_TYPE_* values or a value in the vendor-reserved
+ //! range.
+ uint8_t hostEndpointType;
+
+ //! Flag indicating if the packageName/endpointName field is valid.
+ uint8_t isNameValid : 1;
+
+ //! Flag indicating if the attributionTag/endpointTag field is valid.
+ uint8_t isTagValid : 1;
+
+ //! A union of null-terminated host name strings.
+ union {
+ //! The Android package name associated with this host, valid if the
+ //! hostEndpointType is CHRE_HOST_ENDPOINT_TYPE_APP or
+ //! CHRE_HOST_ENDPOINT_TYPE_FRAMEWORK. Refer to the Android documentation
+ //! for the package attribute in the app manifest.
+ char packageName[CHRE_MAX_ENDPOINT_NAME_LEN];
+
+ //! A generic endpoint name that can be used for endpoints that
+ //! may not have a package name.
+ char endpointName[CHRE_MAX_ENDPOINT_NAME_LEN];
+ };
+
+ //! A union of null-terminated host tag strings for further identification.
+ union {
+ //! The attribution tag associated with this host that is used to audit
+ //! access to data, which can be valid if the hostEndpointType is
+ //! CHRE_HOST_ENDPOINT_TYPE_APP. Refer to the Android documentation
+ //! regarding data audit using attribution tags.
+ char attributionTag[CHRE_MAX_ENDPOINT_TAG_LEN];
+
+ //! A generic endpoint tag that can be used for endpoints that
+ //! may not have an attribution tag.
+ char endpointTag[CHRE_MAX_ENDPOINT_TAG_LEN];
+ };
+};
+
+/**
+ * An RPC service exposed by a nanoapp.
+ *
+ * The implementation of the RPC interface is not defined by the HAL, and is written
+ * at the messaging endpoint layers (Android app and/or CHRE nanoapp). NanoappRpcService
+ * contains the informational metadata to be consumed by the RPC interface layer.
+ */
+struct chreNanoappRpcService {
+ /**
+ * The unique 64-bit ID of an RPC service exposed by a nanoapp. Note that
+ * the uniqueness is only required within the nanoapp's domain (i.e. the
+ * combination of the nanoapp ID and service id must be unique).
+ */
+ uint64_t id;
+
+ /**
+ * The software version of this service, which follows the sematic
+ * versioning scheme (see semver.org). It follows the format
+ * major.minor.patch, where major and minor versions take up one byte
+ * each, and the patch version takes up the final 2 bytes.
+ */
+ uint32_t version;
+};
+
+/**
+ * Callback which frees data associated with an event.
+ *
+ * This callback is (optionally) provided to the chreSendEvent() method as
+ * a means for freeing the event data and performing any other cleanup
+ * necessary when the event is completed. When this callback is invoked,
+ * 'eventData' is no longer needed and can be released.
+ *
+ * @param eventType The 'eventType' argument from chreSendEvent().
+ * @param eventData The 'eventData' argument from chreSendEvent().
+ *
+ * @see chreSendEvent
+ */
+typedef void (chreEventCompleteFunction)(uint16_t eventType, void *eventData);
+
+/**
+ * Callback which frees a message.
+ *
+ * This callback is (optionally) provided to the chreSendMessageToHostEndpoint()
+ * method as a means for freeing the message. When this callback is invoked,
+ * 'message' is no longer needed and can be released. Note that this in
+ * no way assures that said message did or did not make it to the host, simply
+ * that this memory is no longer needed.
+ *
+ * @param message The 'message' argument from chreSendMessageToHostEndpoint().
+ * @param messageSize The 'messageSize' argument from
+ * chreSendMessageToHostEndpoint().
+ *
+ * @see chreSendMessageToHostEndpoint
+ */
+typedef void (chreMessageFreeFunction)(void *message, size_t messageSize);
+
+
+/**
+ * Enqueue an event to be sent to another nanoapp.
+ *
+ * @param eventType This is a user-defined event type, of at least the
+ * value CHRE_EVENT_FIRST_USER_VALUE. It is illegal to attempt to use any
+ * of the CHRE_EVENT_* values reserved for the CHRE.
+ * @param eventData A pointer value that will be understood by the receiving
+ * app. Note that NULL is perfectly acceptable. It also is not required
+ * that this be a valid pointer, although if this nanoapp is intended to
+ * work on arbitrary CHRE implementations, then the size of a
+ * pointer cannot be assumed to be a certain size. Note that the caller
+ * no longer owns this memory after the call.
+ * @param freeCallback A pointer to a callback function. After the lifetime
+ * of 'eventData' is over (either through successful delivery or the event
+ * being dropped), this callback will be invoked. This argument is allowed
+ * to be NULL, in which case no callback will be invoked.
+ * @param targetInstanceId The ID of the instance we're delivering this event
+ * to. Note that this is allowed to be our own instance. The instance ID
+ * of a nanoapp can be retrieved by using chreGetNanoappInfoByInstanceId().
+ * @return true if the event was enqueued, false otherwise. Note that even
+ * if this method returns 'false', the 'freeCallback' will be invoked,
+ * if non-NULL. Note in the 'false' case, the 'freeCallback' may be
+ * invoked directly from within chreSendEvent(), so it's necessary
+ * for nanoapp authors to avoid possible recursion with this.
+ *
+ * @see chreEventDataFreeFunction
+ */
+bool chreSendEvent(uint16_t eventType, void *eventData,
+ chreEventCompleteFunction *freeCallback,
+ uint32_t targetInstanceId);
+
+/**
+ * Send a message to the host, using the broadcast endpoint
+ * CHRE_HOST_ENDPOINT_BROADCAST. Refer to chreSendMessageToHostEndpoint() for
+ * further details.
+ *
+ * @see chreSendMessageToHostEndpoint
+ *
+ * @deprecated New code should use chreSendMessageToHostEndpoint() instead of
+ * this function. A future update to the API may cause references to this
+ * function to produce a compiler warning.
+ */
+bool chreSendMessageToHost(void *message, uint32_t messageSize,
+ uint32_t messageType,
+ chreMessageFreeFunction *freeCallback)
+ CHRE_DEPRECATED("Use chreSendMessageToHostEndpoint instead");
+
+/**
+ * Send a message to the host, using CHRE_MESSAGE_PERMISSION_NONE for the
+ * associated message permissions. This method must only be used if no data
+ * provided by CHRE's audio, GNSS, WiFi, and WWAN APIs was used to produce the
+ * contents of the message being sent. Refer to chreSendMessageWithPermissions()
+ * for further details.
+ *
+ * @see chreSendMessageWithPermissions
+ *
+ * @since v1.1
+ */
+bool chreSendMessageToHostEndpoint(void *message, size_t messageSize,
+ uint32_t messageType, uint16_t hostEndpoint,
+ chreMessageFreeFunction *freeCallback);
+
+/**
+ * Send a message to the host, waking it up if it is currently asleep.
+ *
+ * This message is by definition arbitrarily defined. Since we're not
+ * just a passing a pointer to memory around the system, but need to copy
+ * this into various buffers to send it to the host, the CHRE
+ * implementation cannot be asked to support an arbitrarily large message
+ * size. As a result, we have the CHRE implementation define
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE.
+ *
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE is not given a value by the Platform API. The
+ * Platform API does define CHRE_MESSAGE_TO_HOST_MINIMUM_MAX_SIZE, and requires
+ * that CHRE_MESSAGE_TO_HOST_MAX_SIZE is at least that value.
+ *
+ * As a result, if your message sizes are all less than
+ * CHRE_MESSAGE_TO_HOST_MINIMUM_MAX_SIZE, then you have no concerns on any
+ * CHRE implementation. If your message sizes are larger, you'll need to
+ * come up with a strategy for splitting your message across several calls
+ * to this method. As long as that strategy works for
+ * CHRE_MESSAGE_TO_HOST_MINIMUM_MAX_SIZE, it will work across all CHRE
+ * implementations (although on some implementations less calls to this
+ * method may be necessary).
+ *
+ * When sending a message to the host, the ContextHub service will enforce
+ * the host client has been granted Android-level permissions corresponding to
+ * the ones the nanoapp declares it uses through CHRE_NANOAPP_USES_AUDIO, etc.
+ * In addition to this, the permissions bitmask provided as input to this method
+ * results in the Android framework using app-ops to verify and log access upon
+ * message delivery to an application. This is primarily useful for ensuring
+ * accurate attribution for messages generated using permission-controlled data.
+ * The bitmask declared by the nanoapp for this message must be a
+ * subset of the permissions it declared it would use at build time or the
+ * message will be rejected.
+ *
+ * Nanoapps must use this method if the data they are sending contains or was
+ * derived from any data sampled through CHRE's audio, GNSS, WiFi, or WWAN APIs.
+ * Additionally, if vendors add APIs to expose data that would be guarded by a
+ * permission in Android, vendors must support declaring a message permission
+ * through this method.
+ *
+ * @param message Pointer to a block of memory to send to the host.
+ * NULL is acceptable only if messageSize is 0. If non-NULL, this
+ * must be a legitimate pointer (that is, unlike chreSendEvent(), a small
+ * integral value cannot be cast to a pointer for this). Note that the
+ * caller no longer owns this memory after the call.
+ * @param messageSize The size, in bytes, of the given message. If this exceeds
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE, the message will be rejected.
+ * @param messageType Message type sent to the app on the host.
+ * NOTE: In CHRE API v1.0, support for forwarding this field to the host was
+ * not strictly required, and some implementations did not support it.
+ * However, its support is mandatory as of v1.1.
+ * NOTE: The value CHRE_MESSAGE_TYPE_RPC is reserved for usage by RPC
+ * libraries and normally should not be directly used by nanoapps.
+ * @param hostEndpoint An identifier for the intended recipient of the message,
+ * or CHRE_HOST_ENDPOINT_BROADCAST if all registered endpoints on the host
+ * should receive the message. Endpoint identifiers are assigned on the
+ * host side, and nanoapps may learn of the host endpoint ID of an intended
+ * recipient via an initial message sent by the host. This parameter is
+ * always treated as CHRE_HOST_ENDPOINT_BROADCAST if running on a CHRE API
+ * v1.0 implementation. CHRE_HOST_ENDPOINT_BROADCAST isn't allowed to be
+ * specified if anything other than CHRE_MESSAGE_PERMISSION_NONE is given
+ * as messagePermissions since doing so would potentially attribute
+ * permissions usage to host clients that don't intend to consume the data.
+ * @param messagePermissions Bitmasked CHRE_MESSAGE_PERMISSION_ values that will
+ * be converted to corresponding Android-level permissions and attributed
+ * the host endpoint upon consumption of the message.
+ * @param freeCallback A pointer to a callback function. After the lifetime
+ * of 'message' is over (which does not assure that 'message' made it to
+ * the host, just that the transport layer no longer needs this memory),
+ * this callback will be invoked. This argument is allowed
+ * to be NULL, in which case no callback will be invoked.
+ * @return true if the message was accepted for transmission, false otherwise.
+ * Note that even if this method returns 'false', the 'freeCallback' will
+ * be invoked, if non-NULL. In either case, the 'freeCallback' may be
+ * invoked directly from within chreSendMessageToHostEndpoint(), so it's
+ * necessary for nanoapp authors to avoid possible recursion with this.
+ *
+ * @see chreMessageFreeFunction
+ *
+ * @since v1.5
+ */
+bool chreSendMessageWithPermissions(void *message, size_t messageSize,
+ uint32_t messageType, uint16_t hostEndpoint,
+ uint32_t messagePermissions,
+ chreMessageFreeFunction *freeCallback);
+
+/**
+ * Send a reliable message to the host.
+ *
+ * A reliable message is similar to a message sent by
+ * chreSendMessageWithPermissions() with the difference that the host
+ * acknowledges the message by sending a status back to the nanoapp, and the
+ * CHRE implementation takes care of retries to help mitigate transient
+ * failures. The final result of attempting to deliver the message is given
+ * via a CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT event. The maximum time until the
+ * nanoapp will receive the result is CHRE_ASYNC_RESULT_TIMEOUT_NS.
+ *
+ * The free callback is invoked before the async status is delivered to the
+ * nanoapp via the CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT event and does not
+ * indicate successful delivery of the message.
+ *
+ * The API is similar to chreSendMessageWithPermissions() with a few
+ * differences:
+ * - chreSendReliableMessageAsync() takes an extra cookie that is part of the
+ * async result
+ * - When the message is accepted for transmission (the function returns true)
+ * then an async status is delivered to the nanoapp when the transmission
+ * completes either successfully or in error via the
+ * CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT event.
+ * - For any reliable messages pending completion at nanoapp unload:
+ * - At least one delivery attempt will be made.
+ * - The free callback will be invoked.
+ * - The async result event will not be delivered.
+ * - The error codes received are:
+ * - CHRE_ERROR_DESTINATION_NOT_FOUND if the destination was not found.
+ * - CHRE_ERROR if there was a permanent error.
+ * - CHRE_ERROR_TIMEOUT if there was no response from the recipient
+ * (a timeout).
+ *
+ * This is an optional feature, and this function will always return
+ * false if CHRE_CAPABILITIES_RELIABLE_MESSAGES is not indicated by
+ * chreGetCapabilities().
+ *
+ * @see chreSendMessageWithPermissions
+ *
+ * @since v1.10
+ */
+bool chreSendReliableMessageAsync(void *message, size_t messageSize,
+ uint32_t messageType, uint16_t hostEndpoint,
+ uint32_t messagePermissions,
+ chreMessageFreeFunction *freeCallback,
+ const void *cookie);
+
+/**
+ * Queries for information about a nanoapp running in the system.
+ *
+ * In the current API, appId is required to be unique, i.e. there cannot be two
+ * nanoapps running concurrently with the same appId. If this restriction is
+ * removed in a future API version and multiple instances of the same appId are
+ * present, this function must always return the first app to start.
+ *
+ * @param appId Identifier for the nanoapp that the caller is requesting
+ * information about.
+ * @param info Output parameter. If this function returns true, this structure
+ * will be populated with details of the specified nanoapp.
+ * @return true if a nanoapp with the given ID is currently running, and the
+ * supplied info parameter was populated with its information.
+ *
+ * @since v1.1
+ */
+bool chreGetNanoappInfoByAppId(uint64_t appId, struct chreNanoappInfo *info);
+
+/**
+ * Queries for information about a nanoapp running in the system, using the
+ * runtime unique identifier. This method can be used to get information about
+ * the sender of an event.
+ *
+ * @param instanceId
+ * @param info Output parameter. If this function returns true, this structure
+ * will be populated with details of the specified nanoapp.
+ * @return true if a nanoapp with the given instance ID is currently running,
+ * and the supplied info parameter was populated with its information.
+ *
+ * @since v1.1
+ */
+bool chreGetNanoappInfoByInstanceId(uint32_t instanceId,
+ struct chreNanoappInfo *info);
+
+/**
+ * Configures whether this nanoapp will be notified when other nanoapps in the
+ * system start and stop, via CHRE_EVENT_NANOAPP_STARTED and
+ * CHRE_EVENT_NANOAPP_STOPPED. These events are disabled by default, and if a
+ * nanoapp is not interested in interacting with other nanoapps, then it does
+ * not need to register for them. However, if inter-nanoapp communication is
+ * desired, nanoapps are recommended to call this function from nanoappStart().
+ *
+ * If running on a CHRE platform that only supports v1.0 of the CHRE API, this
+ * function has no effect.
+ *
+ * @param enable true to enable these events, false to disable
+ *
+ * @see CHRE_EVENT_NANOAPP_STARTED
+ * @see CHRE_EVENT_NANOAPP_STOPPED
+ *
+ * @since v1.1
+ */
+void chreConfigureNanoappInfoEvents(bool enable);
+
+/**
+ * Configures whether this nanoapp will be notified when the host (applications
+ * processor) transitions between wake and sleep, via CHRE_EVENT_HOST_AWAKE and
+ * CHRE_EVENT_HOST_ASLEEP. As chreSendMessageToHostEndpoint() wakes the host if
+ * it is asleep, these events can be used to opportunistically send data to the
+ * host only when it wakes up for some other reason. Note that this event is
+ * not instantaneous - there is an inherent delay in CHRE observing power state
+ * changes of the host processor, which may be significant depending on the
+ * implementation, especially in the wake to sleep direction. Therefore,
+ * nanoapps are not guaranteed that messages sent to the host between AWAKE and
+ * ASLEEP events will not trigger a host wakeup. However, implementations must
+ * ensure that the nominal wake-up notification latency is strictly less than
+ * the minimum wake-sleep time of the host processor. Implementations are also
+ * encouraged to minimize this and related latencies where possible, to avoid
+ * unnecessary host wake-ups.
+ *
+ * These events are only sent on transitions, so the initial state will not be
+ * sent to the nanoapp as an event - use chreIsHostAwake().
+ *
+ * @param enable true to enable these events, false to disable
+ *
+ * @see CHRE_EVENT_HOST_AWAKE
+ * @see CHRE_EVENT_HOST_ASLEEP
+ *
+ * @since v1.2
+ */
+void chreConfigureHostSleepStateEvents(bool enable);
+
+/**
+ * Retrieves the current sleep/wake state of the host (applications processor).
+ * Note that, as with the CHRE_EVENT_HOST_AWAKE and CHRE_EVENT_HOST_ASLEEP
+ * events, there is no guarantee that CHRE's view of the host processor's sleep
+ * state is instantaneous, and it may also change between querying the state and
+ * performing a host-waking action like sending a message to the host.
+ *
+ * @return true if by CHRE's own estimation the host is currently awake,
+ * false otherwise
+ *
+ * @since v1.2
+ */
+bool chreIsHostAwake(void);
+
+/**
+ * Configures whether this nanoapp will be notified when CHRE is collecting
+ * debug dumps, via CHRE_EVENT_DEBUG_DUMP. This event is disabled by default,
+ * and if a nanoapp is not interested in logging its debug data, then it does
+ * not need to register for it.
+ *
+ * @param enable true to enable receipt of this event, false to disable.
+ *
+ * @see CHRE_EVENT_DEBUG_DUMP
+ * @see chreDebugDumpLog
+ *
+ * @since v1.4
+ */
+void chreConfigureDebugDumpEvent(bool enable);
+
+/**
+ * Configures whether this nanoapp will receive updates regarding a host
+ * endpoint that is connected with the Context Hub.
+ *
+ * If this API succeeds, the nanoapp will receive disconnection notifications,
+ * via the CHRE_EVENT_HOST_ENDPOINT_NOTIFICATION event with an eventData of type
+ * chreHostEndpointNotification with its notificationType set to
+ * HOST_ENDPOINT_NOTIFICATION_TYPE_DISCONNECT, which can be invoked if the host
+ * has disconnected from the Context Hub either explicitly or implicitly (e.g.
+ * crashes). Nanoapps can use this notifications to clean up any resources
+ * associated with this host endpoint.
+ *
+ * @param hostEndpointId The host endpoint ID to configure notifications for.
+ * @param enable true to enable notifications.
+ *
+ * @return true on success
+ *
+ * @see chreMessageFromHostData
+ * @see chreHostEndpointNotification
+ * @see CHRE_EVENT_HOST_ENDPOINT_NOTIFICATION
+ *
+ * @since v1.6
+ */
+bool chreConfigureHostEndpointNotifications(uint16_t hostEndpointId,
+ bool enable);
+
+/**
+ * Publishes RPC services from this nanoapp.
+ *
+ * When this API is invoked, the list of RPC services will be provided to
+ * host applications interacting with the nanoapp.
+ *
+ * This function must be invoked from nanoappStart(), to guarantee stable output
+ * of the list of RPC services supported by the nanoapp.
+ *
+ * Although nanoapps are recommended to only call this API once with all
+ * services it intends to publish, if it is called multiple times, each
+ * call will append to the list of published services.
+ *
+ * Starting in CHRE API v1.8, the implementation must allow for a nanoapp to
+ * publish at least CHRE_MINIMUM_RPC_SERVICE_LIMIT services and at most
+ * UINT8_MAX services. If calling this function would result in exceeding
+ * the limit, the services must not be published and it must return false.
+ *
+ * @param services A non-null pointer to the list of RPC services to publish.
+ * @param numServices The number of services to publish, i.e. the length of the
+ * services array.
+ *
+ * @return true if the publishing is successful.
+ *
+ * @since v1.6
+ */
+bool chrePublishRpcServices(struct chreNanoappRpcService *services,
+ size_t numServices);
+
+/**
+ * Retrieves metadata for a given host endpoint ID.
+ *
+ * This API will provide metadata regarding an endpoint associated with a
+ * host endpoint ID. The nanoapp should use this API to determine more
+ * information about a host endpoint that has sent a message to the nanoapp,
+ * after receiving a chreMessageFromHostData (which includes the endpoint ID).
+ *
+ * If the given host endpoint ID is not associated with a valid host (or if the
+ * client has disconnected from the Android or CHRE framework, i.e. no longer
+ * able to send messages to CHRE), this method will return false and info will
+ * not be populated.
+ *
+ * @param hostEndpointId The endpoint ID of the host to get info for.
+ * @param info The non-null pointer to where the metadata will be stored.
+ *
+ * @return true if info has been successfully populated.
+ *
+ * @since v1.6
+ */
+bool chreGetHostEndpointInfo(uint16_t hostEndpointId,
+ struct chreHostEndpointInfo *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_EVENT_H_ */
+
diff --git a/chre_api/legacy/v1_10/chre/gnss.h b/chre_api/legacy/v1_10/chre/gnss.h
new file mode 100644
index 0000000..a326e85
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/gnss.h
@@ -0,0 +1,607 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_GNSS_H_
+#define _CHRE_GNSS_H_
+
+/**
+ * @file
+ * Global Navigation Satellite System (GNSS) API.
+ *
+ * These structures and definitions are based on the Android N GPS HAL.
+ * Refer to that header file (located at this path as of the time of this
+ * comment: hardware/libhardware/include/hardware/gps.h) and associated
+ * documentation for further details and explanations for these fields.
+ * References in comments like "(ref: GnssAccumulatedDeltaRangeState)" map to
+ * the relevant element in the GPS HAL where additional information can be
+ * found.
+ *
+ * In general, the parts of this API that are taken from the GPS HAL follow the
+ * naming conventions established in that interface rather than the CHRE API
+ * conventions, in order to avoid confusion and enable code re-use where
+ * applicable.
+ */
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <chre/common.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The set of flags that may be returned by chreGnssGetCapabilities()
+ * @defgroup CHRE_GNSS_CAPABILITIES
+ * @{
+ */
+
+//! A lack of flags indicates that GNSS is not supported in this CHRE
+#define CHRE_GNSS_CAPABILITIES_NONE UINT32_C(0)
+
+//! GNSS position fixes are supported via chreGnssLocationSessionStartAsync()
+#define CHRE_GNSS_CAPABILITIES_LOCATION UINT32_C(1 << 0)
+
+//! GNSS raw measurements are supported via
+//! chreGnssMeasurementSessionStartAsync()
+#define CHRE_GNSS_CAPABILITIES_MEASUREMENTS UINT32_C(1 << 1)
+
+//! Location fixes supplied from chreGnssConfigurePassiveLocationListener()
+//! are tapped in at the GNSS engine level, so they include additional fixes
+//! such as those requested by the AP, and not just those requested by other
+//! nanoapps within CHRE (which is the case when this flag is not set)
+#define CHRE_GNSS_CAPABILITIES_GNSS_ENGINE_BASED_PASSIVE_LISTENER \
+ UINT32_C(1 << 2)
+
+/** @} */
+
+/**
+ * The current version of struct chreGnssDataEvent associated with this API
+ */
+#define CHRE_GNSS_DATA_EVENT_VERSION UINT8_C(0)
+
+/**
+ * The maximum time the CHRE implementation is allowed to elapse before sending
+ * an event with the result of an asynchronous request, unless specified
+ * otherwise
+ */
+#define CHRE_GNSS_ASYNC_RESULT_TIMEOUT_NS (5 * CHRE_NSEC_PER_SEC)
+
+/**
+ * Produce an event ID in the block of IDs reserved for GNSS
+ * @param offset Index into GNSS event ID block; valid range [0,15]
+ */
+#define CHRE_GNSS_EVENT_ID(offset) (CHRE_EVENT_GNSS_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreAsyncResult
+ *
+ * Communicates the asynchronous result of a request to the GNSS API, such as
+ * starting a location session via chreGnssLocationSessionStartAsync(). The
+ * requestType field in chreAsyncResult is set to a value from enum
+ * chreGnssRequestType.
+ */
+#define CHRE_EVENT_GNSS_ASYNC_RESULT CHRE_GNSS_EVENT_ID(0)
+
+/**
+ * nanoappHandleEvent argument: struct chreGnssLocationEvent
+ *
+ * Represents a location fix provided by the GNSS subsystem.
+ */
+#define CHRE_EVENT_GNSS_LOCATION CHRE_GNSS_EVENT_ID(1)
+
+/**
+ * nanoappHandleEvent argument: struct chreGnssDataEvent
+ *
+ * Represents a set of GNSS measurements with associated clock data.
+ */
+#define CHRE_EVENT_GNSS_DATA CHRE_GNSS_EVENT_ID(2)
+
+// NOTE: Do not add new events with ID > 15; only values 0-15 are reserved
+// (see chre/event.h)
+
+// Flags indicating the Accumulated Delta Range's states
+// (ref: GnssAccumulatedDeltaRangeState)
+#define CHRE_GNSS_ADR_STATE_UNKNOWN UINT16_C(0)
+#define CHRE_GNSS_ADR_STATE_VALID UINT16_C(1 << 0)
+#define CHRE_GNSS_ADR_STATE_RESET UINT16_C(1 << 1)
+#define CHRE_GNSS_ADR_STATE_CYCLE_SLIP UINT16_C(1 << 2)
+
+// Flags to indicate what fields in chreGnssClock are valid (ref: GnssClockFlags)
+#define CHRE_GNSS_CLOCK_HAS_LEAP_SECOND UINT16_C(1 << 0)
+#define CHRE_GNSS_CLOCK_HAS_TIME_UNCERTAINTY UINT16_C(1 << 1)
+#define CHRE_GNSS_CLOCK_HAS_FULL_BIAS UINT16_C(1 << 2)
+#define CHRE_GNSS_CLOCK_HAS_BIAS UINT16_C(1 << 3)
+#define CHRE_GNSS_CLOCK_HAS_BIAS_UNCERTAINTY UINT16_C(1 << 4)
+#define CHRE_GNSS_CLOCK_HAS_DRIFT UINT16_C(1 << 5)
+#define CHRE_GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY UINT16_C(1 << 6)
+
+// Flags to indicate which values are valid in a GpsLocation
+// (ref: GpsLocationFlags)
+#define CHRE_GPS_LOCATION_HAS_LAT_LONG UINT16_C(1 << 0)
+#define CHRE_GPS_LOCATION_HAS_ALTITUDE UINT16_C(1 << 1)
+#define CHRE_GPS_LOCATION_HAS_SPEED UINT16_C(1 << 2)
+#define CHRE_GPS_LOCATION_HAS_BEARING UINT16_C(1 << 3)
+#define CHRE_GPS_LOCATION_HAS_ACCURACY UINT16_C(1 << 4)
+
+//! @since v1.3
+#define CHRE_GPS_LOCATION_HAS_ALTITUDE_ACCURACY UINT16_C(1 << 5)
+//! @since v1.3
+#define CHRE_GPS_LOCATION_HAS_SPEED_ACCURACY UINT16_C(1 << 6)
+//! @since v1.3
+#define CHRE_GPS_LOCATION_HAS_BEARING_ACCURACY UINT16_C(1 << 7)
+
+/**
+ * The maximum number of instances of struct chreGnssMeasurement that may be
+ * included in a single struct chreGnssDataEvent.
+ *
+ * The value of this struct was increased from 64 to 128 in CHRE v1.5. For
+ * nanoapps targeting CHRE v1.4 or lower, the measurement_count will be capped
+ * at 64.
+ */
+#define CHRE_GNSS_MAX_MEASUREMENT UINT8_C(128)
+#define CHRE_GNSS_MAX_MEASUREMENT_PRE_1_5 UINT8_C(64)
+
+// Flags indicating the GNSS measurement state (ref: GnssMeasurementState)
+#define CHRE_GNSS_MEASUREMENT_STATE_UNKNOWN UINT16_C(0)
+#define CHRE_GNSS_MEASUREMENT_STATE_CODE_LOCK UINT16_C(1 << 0)
+#define CHRE_GNSS_MEASUREMENT_STATE_BIT_SYNC UINT16_C(1 << 1)
+#define CHRE_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC UINT16_C(1 << 2)
+#define CHRE_GNSS_MEASUREMENT_STATE_TOW_DECODED UINT16_C(1 << 3)
+#define CHRE_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS UINT16_C(1 << 4)
+#define CHRE_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC UINT16_C(1 << 5)
+#define CHRE_GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC UINT16_C(1 << 6)
+#define CHRE_GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED UINT16_C(1 << 7)
+#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC UINT16_C(1 << 8)
+#define CHRE_GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC UINT16_C(1 << 9)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK UINT16_C(1 << 10)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK UINT16_C(1 << 11)
+#define CHRE_GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC UINT16_C(1 << 12)
+#define CHRE_GNSS_MEASUREMENT_STATE_SBAS_SYNC UINT16_C(1 << 13)
+
+#define CHRE_GNSS_MEASUREMENT_CARRIER_FREQUENCY_UNKNOWN 0.f
+
+/**
+ * Indicates a type of request made in this API. Used to populate the resultType
+ * field of struct chreAsyncResult sent with CHRE_EVENT_GNSS_ASYNC_RESULT.
+ */
+enum chreGnssRequestType {
+ CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_START = 1,
+ CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_STOP = 2,
+ CHRE_GNSS_REQUEST_TYPE_MEASUREMENT_SESSION_START = 3,
+ CHRE_GNSS_REQUEST_TYPE_MEASUREMENT_SESSION_STOP = 4,
+};
+
+/**
+ * Constellation type associated with an SV
+ */
+enum chreGnssConstellationType {
+ CHRE_GNSS_CONSTELLATION_UNKNOWN = 0,
+ CHRE_GNSS_CONSTELLATION_GPS = 1,
+ CHRE_GNSS_CONSTELLATION_SBAS = 2,
+ CHRE_GNSS_CONSTELLATION_GLONASS = 3,
+ CHRE_GNSS_CONSTELLATION_QZSS = 4,
+ CHRE_GNSS_CONSTELLATION_BEIDOU = 5,
+ CHRE_GNSS_CONSTELLATION_GALILEO = 6,
+};
+
+/**
+ * Enumeration of available values for the chreGnssMeasurement multipath indicator
+ */
+enum chreGnssMultipathIndicator {
+ //! The indicator is not available or unknown
+ CHRE_GNSS_MULTIPATH_INDICATOR_UNKNOWN = 0,
+ //! The measurement is indicated to be affected by multipath
+ CHRE_GNSS_MULTIPATH_INDICATOR_PRESENT = 1,
+ //! The measurement is indicated to be not affected by multipath
+ CHRE_GNSS_MULTIPATH_INDICATOR_NOT_PRESENT = 2,
+};
+
+/**
+ * Represents an estimate of the GNSS clock time (see the Android GPS HAL for
+ * more detailed information)
+ */
+struct chreGnssClock {
+ //! The GNSS receiver hardware clock value in nanoseconds, including
+ //! uncertainty
+ int64_t time_ns;
+
+ //! The difference between hardware clock inside GNSS receiver and the
+ //! estimated GNSS time in nanoseconds; contains bias uncertainty
+ int64_t full_bias_ns;
+
+ //! Sub-nanosecond bias, adds to full_bias_ns
+ float bias_ns;
+
+ //! The clock's drift in nanoseconds per second
+ float drift_nsps;
+
+ //! 1-sigma uncertainty associated with the clock's bias in nanoseconds
+ float bias_uncertainty_ns;
+
+ //! 1-sigma uncertainty associated with the clock's drift in nanoseconds
+ //! per second
+ float drift_uncertainty_nsps;
+
+ //! While this number stays the same, timeNs should flow continuously
+ uint32_t hw_clock_discontinuity_count;
+
+ //! A set of flags indicating the validity of the fields in this data
+ //! structure (see GNSS_CLOCK_HAS_*)
+ uint16_t flags;
+
+ //! Reserved for future use; set to 0
+ uint8_t reserved[2];
+};
+
+/**
+ * Represents a GNSS measurement; contains raw and computed information (see the
+ * Android GPS HAL for more detailed information)
+ */
+struct chreGnssMeasurement {
+ //! Hardware time offset from time_ns for this measurement, in nanoseconds
+ int64_t time_offset_ns;
+
+ //! Accumulated delta range since the last channel reset in micro-meters
+ int64_t accumulated_delta_range_um;
+
+ //! Received GNSS satellite time at the time of measurement, in nanoseconds
+ int64_t received_sv_time_in_ns;
+
+ //! 1-sigma uncertainty of received GNSS satellite time, in nanoseconds
+ int64_t received_sv_time_uncertainty_in_ns;
+
+ //! Pseudorange rate at the timestamp in meters per second (uncorrected)
+ float pseudorange_rate_mps;
+
+ //! 1-sigma uncertainty of pseudorange rate in meters per second
+ float pseudorange_rate_uncertainty_mps;
+
+ //! 1-sigma uncertainty of the accumulated delta range in meters
+ float accumulated_delta_range_uncertainty_m;
+
+ //! Carrier-to-noise density in dB-Hz, in the range of [0, 63]
+ float c_n0_dbhz;
+
+ //! Signal to noise ratio (dB), power above observed noise at correlators
+ float snr_db;
+
+ //! Satellite sync state flags (GNSS_MEASUREMENT_STATE_*) - sets modulus for
+ //! received_sv_time_in_ns
+ uint16_t state;
+
+ //! Set of ADR state flags (GNSS_ADR_STATE_*)
+ uint16_t accumulated_delta_range_state;
+
+ //! Satellite vehicle ID number
+ int16_t svid;
+
+ //! Constellation of the given satellite vehicle
+ //! @see #chreGnssConstellationType
+ uint8_t constellation;
+
+ //! @see #chreGnssMultipathIndicator
+ uint8_t multipath_indicator;
+
+ //! Carrier frequency of the signal tracked in Hz.
+ //! For example, it can be the GPS central frequency for L1 = 1575.45 MHz,
+ //! or L2 = 1227.60 MHz, L5 = 1176.45 MHz, various GLO channels, etc.
+ //!
+ //! Set to CHRE_GNSS_MEASUREMENT_CARRIER_FREQUENCY_UNKNOWN if not reported.
+ //!
+ //! For an L1, L5 receiver tracking a satellite on L1 and L5 at the same
+ //! time, two chreGnssMeasurement structs must be reported for this same
+ //! satellite, in one of the measurement structs, all the values related to
+ //! L1 must be filled, and in the other all of the values related to L5
+ //! must be filled.
+ //! @since v1.4
+ float carrier_frequency_hz;
+};
+
+/**
+ * Data structure sent with events associated with CHRE_EVENT_GNSS_DATA, enabled
+ * via chreGnssMeasurementSessionStartAsync()
+ */
+struct chreGnssDataEvent {
+ //! Indicates the version of the structure, for compatibility purposes.
+ //! Clients do not normally need to worry about this field; the CHRE
+ //! implementation guarantees that it only sends the client the structure
+ //! version it expects.
+ uint8_t version;
+
+ //! Number of chreGnssMeasurement entries included in this event. Must be in
+ //! the range [0, CHRE_GNSS_MAX_MEASUREMENT]
+ uint8_t measurement_count;
+
+ //! Reserved for future use; set to 0
+ uint8_t reserved[6];
+
+ struct chreGnssClock clock;
+
+ //! Pointer to an array containing measurement_count measurements
+ const struct chreGnssMeasurement *measurements;
+};
+
+/**
+ * Data structure sent with events of type CHRE_EVENT_GNSS_LOCATION, enabled via
+ * chreGnssLocationSessionStartAsync(). This is modeled after GpsLocation in the
+ * GPS HAL, but does not use the double data type.
+ */
+struct chreGnssLocationEvent {
+ //! UTC timestamp for location fix in milliseconds since January 1, 1970
+ uint64_t timestamp;
+
+ //! Fixed point latitude, degrees times 10^7 (roughly centimeter resolution)
+ int32_t latitude_deg_e7;
+
+ //! Fixed point longitude, degrees times 10^7 (roughly centimeter
+ //! resolution)
+ int32_t longitude_deg_e7;
+
+ //! Altitude in meters above the WGS 84 reference ellipsoid
+ float altitude;
+
+ //! Horizontal speed in meters per second
+ float speed;
+
+ //! Clockwise angle between north and current heading, in degrees; range
+ //! [0, 360)
+ float bearing;
+
+ //! Expected horizontal accuracy in meters such that a circle with a radius
+ //! of length 'accuracy' from the latitude and longitude has a 68%
+ //! probability of including the true location.
+ float accuracy;
+
+ //! A set of flags indicating which fields in this structure are valid.
+ //! If any fields are not available, the flag must not be set and the field
+ //! must be initialized to 0.
+ //! @see #GpsLocationFlags
+ uint16_t flags;
+
+ //! Reserved for future use; set to 0
+ //! @since v1.3
+ uint8_t reserved[2];
+
+ //! Expected vertical accuracy in meters such that a range of
+ //! 2 * altitude_accuracy centered around altitude has a 68% probability of
+ //! including the true altitude.
+ //! @since v1.3
+ float altitude_accuracy;
+
+ //! Expected speed accuracy in meters per second such that a range of
+ //! 2 * speed_accuracy centered around speed has a 68% probability of
+ //! including the true speed.
+ //! @since v1.3
+ float speed_accuracy;
+
+ //! Expected bearing accuracy in degrees such that a range of
+ //! 2 * bearing_accuracy centered around bearing has a 68% probability of
+ //! including the true bearing.
+ //! @since v1.3
+ float bearing_accuracy;
+};
+
+
+/**
+ * Retrieves a set of flags indicating the GNSS features supported by the
+ * current CHRE implementation. The value returned by this function must be
+ * consistent for the entire duration of the Nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_GNSS_CAPABILITIES_* flags set
+ *
+ * @since v1.1
+ */
+uint32_t chreGnssGetCapabilities(void);
+
+/**
+ * Nanoapps must define CHRE_NANOAPP_USES_GNSS somewhere in their build
+ * system (e.g. Makefile) if the nanoapp needs to use the following GNSS APIs.
+ * In addition to allowing access to these APIs, defining this macro will also
+ * ensure CHRE enforces that all host clients this nanoapp talks to have the
+ * required Android permissions needed to listen to GNSS data by adding metadata
+ * to the nanoapp.
+ */
+#if defined(CHRE_NANOAPP_USES_GNSS) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+/**
+ * Initiates a GNSS positioning session, or changes the requested interval of an
+ * existing session. If starting or modifying the session was successful, then
+ * the GNSS engine will work on determining the device's position.
+ *
+ * This result of this request is delivered asynchronously via an event of type
+ * CHRE_EVENT_GNSS_ASYNC_RESULT. Refer to the note in {@link #chreAsyncResult}
+ * for more details. If the "Location" setting is disabled at the Android level,
+ * the CHRE implementation is expected to return a result with
+ * CHRE_ERROR_FUNCTION_DISABLED.
+ *
+ * If chreGnssGetCapabilities() returns a value that does not have the
+ * CHRE_GNSS_CAPABILITIES_LOCATION flag set, then this method will return false.
+ *
+ * @param minIntervalMs The desired minimum interval between location fixes
+ * delivered to the client via CHRE_EVENT_GNSS_LOCATION, in milliseconds.
+ * The requesting client must allow for fixes to be delivered at shorter
+ * or longer interval than requested. For example, adverse RF conditions
+ * may result in fixes arriving at a longer interval, etc.
+ * @param minTimeToNextFixMs The desired minimum time to the next location fix.
+ * If this is 0, the GNSS engine should start working on the next fix
+ * immediately. If greater than 0, the GNSS engine should not spend
+ * measurable power to produce a location fix until this amount of time
+ * has elapsed.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires GNSS permission
+ */
+bool chreGnssLocationSessionStartAsync(uint32_t minIntervalMs,
+ uint32_t minTimeToNextFixMs,
+ const void *cookie);
+
+/**
+ * Terminates an existing GNSS positioning session. If no positioning session
+ * is active at the time of this request, it is treated as if an active session
+ * was successfully ended.
+ *
+ * This result of this request is delivered asynchronously via an event of type
+ * CHRE_EVENT_GNSS_ASYNC_RESULT. Refer to the note in {@link #chreAsyncResult}
+ * for more details.
+ *
+ * After CHRE_EVENT_GNSS_ASYNC_RESULT is delivered to the client, no more
+ * CHRE_EVENT_GNSS_LOCATION events will be delievered until a new location
+ * session is started.
+ *
+ * If chreGnssGetCapabilities() returns a value that does not have the
+ * CHRE_GNSS_CAPABILITIES_LOCATION flag set, then this method will return false.
+ *
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires GNSS permission
+ */
+bool chreGnssLocationSessionStopAsync(const void *cookie);
+
+/**
+ * Initiates a request to receive raw GNSS measurements. A GNSS measurement
+ * session can exist independently of location sessions. In other words, a
+ * Nanoapp is able to receive measurements at its requested interval both with
+ * and without an active location session.
+ *
+ * This result of this request is delivered asynchronously via an event of type
+ * CHRE_EVENT_GNSS_ASYNC_RESULT. Refer to the note in {@link #chreAsyncResult}
+ * for more details. If the "Location" setting is disabled at the Android level,
+ * the CHRE implementation is expected to return a result with
+ * CHRE_ERROR_FUNCTION_DISABLED.
+ *
+ * If chreGnssGetCapabilities() returns a value that does not have the
+ * CHRE_GNSS_CAPABILITIES_MEASUREMENTS flag set, then this method will return
+ * false.
+ *
+ * @param minIntervalMs The desired minimum interval between measurement reports
+ * delivered via CHRE_EVENT_GNSS_DATA. When requested at 1000ms or
+ * faster, and GNSS measurements are tracked, device should report
+ * measurements as fast as requested, and shall report no slower than
+ * once every 1000ms, on average.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires GNSS permission
+ */
+bool chreGnssMeasurementSessionStartAsync(uint32_t minIntervalMs,
+ const void *cookie);
+
+/**
+ * Terminates an existing raw GNSS measurement session. If no measurement
+ * session is active at the time of this request, it is treated as if an active
+ * session was successfully ended.
+ *
+ * This result of this request is delivered asynchronously via an event of type
+ * CHRE_EVENT_GNSS_ASYNC_RESULT. Refer to the note in {@link #chreAsyncResult}
+ * for more details.
+ *
+ * If chreGnssGetCapabilities() returns a value that does not have the
+ * CHRE_GNSS_CAPABILITIES_MEASUREMENTS flag set, then this method will return
+ * false.
+ *
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires GNSS permission
+ */
+bool chreGnssMeasurementSessionStopAsync(const void *cookie);
+
+/**
+ * Controls whether this nanoapp will passively receive GNSS-based location
+ * fixes produced as a result of location sessions initiated by other entities.
+ * This function allows a nanoapp to opportunistically receive location fixes
+ * via CHRE_EVENT_GNSS_LOCATION events without imposing additional power cost,
+ * though with no guarantees as to when or how often those events will arrive.
+ * There will be no duplication of events if a passive location listener and
+ * location session are enabled in parallel.
+ *
+ * Enabling passive location listening is not required to receive events for an
+ * active location session started via chreGnssLocationSessionStartAsync(). This
+ * setting is independent of the active location session, so modifying one does
+ * not have an effect on the other.
+ *
+ * If chreGnssGetCapabilities() returns a value that does not have the
+ * CHRE_GNSS_CAPABILITIES_LOCATION flag set or the value returned by
+ * chreGetApiVersion() is less than CHRE_API_VERSION_1_2, then this method will
+ * return false.
+ *
+ * If chreGnssGetCapabilities() includes
+ * CHRE_GNSS_CAPABILITIES_GNSS_ENGINE_BASED_PASSIVE_LISTENER, the passive
+ * registration is recorded at the GNSS engine level, so events include fixes
+ * requested by the applications processor and potentially other non-CHRE
+ * clients. If this flag is not set, then only fixes requested by other nanoapps
+ * within CHRE are provided.
+ *
+ * @param enable true to receive opportunistic location fixes, false to disable
+ *
+ * @return true if the configuration was processed successfully, false on error
+ * or if this feature is not supported
+ *
+ * @since v1.2
+ * @note Requires GNSS permission
+ */
+bool chreGnssConfigurePassiveLocationListener(bool enable);
+
+#else /* defined(CHRE_NANOAPP_USES_GNSS) || !defined(CHRE_IS_NANOAPP_BUILD) */
+#define CHRE_GNSS_PERM_ERROR_STRING \
+ "CHRE_NANOAPP_USES_GNSS must be defined when building this nanoapp in " \
+ "order to refer to "
+#define chreGnssLocationSessionStartAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_GNSS_PERM_ERROR_STRING \
+ "chreGnssLocationSessionStartAsync")
+#define chreGnssLocationSessionStopAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_GNSS_PERM_ERROR_STRING \
+ "chreGnssLocationSessionStopAsync")
+#define chreGnssMeasurementSessionStartAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_GNSS_PERM_ERROR_STRING \
+ "chreGnssMeasurementSessionStartAsync")
+#define chreGnssMeasurementSessionStopAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_GNSS_PERM_ERROR_STRING \
+ "chreGnssMeasurementSessionStopAsync")
+#define chreGnssConfigurePassiveLocationListener(...) \
+ CHRE_BUILD_ERROR(CHRE_GNSS_PERM_ERROR_STRING \
+ "chreGnssConfigurePassiveLocationListener")
+#endif /* defined(CHRE_NANOAPP_USES_GNSS) || !defined(CHRE_IS_NANOAPP_BUILD) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_GNSS_H_ */
diff --git a/chre_api/legacy/v1_10/chre/nanoapp.h b/chre_api/legacy/v1_10/chre/nanoapp.h
new file mode 100644
index 0000000..3a1c362
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/nanoapp.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_NANOAPP_H_
+#define _CHRE_NANOAPP_H_
+
+/**
+ * @file
+ * Methods in the Context Hub Runtime Environment which must be implemented
+ * by the nanoapp.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Method invoked by the CHRE when loading the nanoapp.
+ *
+ * Every CHRE method is legal to call from this method.
+ *
+ * @return 'true' if the nanoapp successfully started. 'false' if the nanoapp
+ * failed to properly initialize itself (for example, could not obtain
+ * sufficient memory from the heap). If this method returns 'false', the
+ * nanoapp will be unloaded by the CHRE (and nanoappEnd will
+ * _not_ be invoked in that case).
+ * @see nanoappEnd
+ */
+bool nanoappStart(void);
+
+/**
+ * Method invoked by the CHRE when there is an event for this nanoapp.
+ *
+ * Every CHRE method is legal to call from this method.
+ *
+ * @param senderInstanceId The Instance ID for the source of this event.
+ * Note that this may be CHRE_INSTANCE_ID, indicating that the event
+ * was generated by the CHRE.
+ * @param eventType The event type. This might be one of the CHRE_EVENT_*
+ * types defined in this API. But it might also be a user-defined event.
+ * @param eventData The associated data, if any, for this specific type of
+ * event. From the nanoapp's perspective, this eventData's lifetime ends
+ * when this method returns, and thus any data the nanoapp wishes to
+ * retain must be copied. Note that interpretation of event data is
+ * given by the event type, and for some events may not be a valid
+ * pointer. See documentation of the specific CHRE_EVENT_* types for how to
+ * interpret this data for those. Note that for user events, you will
+ * need to establish what this data means.
+ */
+void nanoappHandleEvent(uint32_t senderInstanceId, uint16_t eventType,
+ const void *eventData);
+
+/**
+ * Method invoked by the CHRE when unloading the nanoapp.
+ *
+ * It is not valid to attempt to send events or messages, or to invoke functions
+ * which will generate events to this app, within the nanoapp implementation of
+ * this function. That means it is illegal for the nanoapp invoke any of the
+ * following:
+ *
+ * - chreSendEvent()
+ * - chreSendMessageToHost()
+ * - chreSensorConfigure()
+ * - chreSensorConfigureModeOnly()
+ * - chreTimerSet()
+ * - etc.
+ *
+ * @see nanoappStart
+ */
+void nanoappEnd(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_NANOAPP_H_ */
diff --git a/chre_api/legacy/v1_10/chre/re.h b/chre_api/legacy/v1_10/chre/re.h
new file mode 100644
index 0000000..b523a41
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/re.h
@@ -0,0 +1,492 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_RE_H_
+#define _CHRE_RE_H_
+
+/**
+ * @file
+ * Some of the core Runtime Environment utilities of the Context Hub
+ * Runtime Environment.
+ *
+ * This includes functions for memory allocation, logging, and timers.
+ */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <chre/toolchain.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The instance ID for the CHRE.
+ *
+ * This ID is used to identify events generated by the CHRE (as
+ * opposed to events generated by another nanoapp).
+ */
+#define CHRE_INSTANCE_ID UINT32_C(0)
+
+/**
+ * A timer ID representing an invalid timer.
+ *
+ * This valid is returned by chreTimerSet() if a timer cannot be
+ * started.
+ */
+#define CHRE_TIMER_INVALID UINT32_C(-1)
+
+
+/**
+ * The maximum size, in characters including null terminator, guaranteed for
+ * logging debug data with one call of chreDebugDumpLog() without getting
+ * truncated.
+ *
+ * @see chreDebugDumpLog
+ * @since v1.4
+ */
+#define CHRE_DEBUG_DUMP_MINIMUM_MAX_SIZE 1000
+
+/**
+ * The set of flags that may be returned by chreGetCapabilities()
+ * @defgroup CHRE_CAPABILITIES
+ * @{
+ */
+
+//! None of the optional capabilities are supported
+#define CHRE_CAPABILITIES_NONE UINT32_C(0)
+
+//! Support for reliable messages.
+//! @see chreSendReliableMessageAsync()
+#define CHRE_CAPABILITIES_RELIABLE_MESSAGES UINT32_C(1 << 0)
+
+/** @} */
+
+/**
+ * Logging levels used to indicate severity level of logging messages.
+ *
+ * CHRE_LOG_ERROR: Something fatal has happened, i.e. something that will have
+ * user-visible consequences and won't be recoverable without explicitly
+ * deleting some data, uninstalling applications, wiping the data
+ * partitions or reflashing the entire phone (or worse).
+ * CHRE_LOG_WARN: Something that will have user-visible consequences but is
+ * likely to be recoverable without data loss by performing some explicit
+ * action, ranging from waiting or restarting an app all the way to
+ * re-downloading a new version of an application or rebooting the device.
+ * CHRE_LOG_INFO: Something interesting to most people happened, i.e. when a
+ * situation is detected that is likely to have widespread impact, though
+ * isn't necessarily an error.
+ * CHRE_LOG_DEBUG: Used to further note what is happening on the device that
+ * could be relevant to investigate and debug unexpected behaviors. You
+ * should log only what is needed to gather enough information about what
+ * is going on about your component.
+ *
+ * There is currently no API to turn on/off logging by level, but we anticipate
+ * adding such in future releases.
+ *
+ * @see chreLog
+ */
+enum chreLogLevel {
+ CHRE_LOG_ERROR,
+ CHRE_LOG_WARN,
+ CHRE_LOG_INFO,
+ CHRE_LOG_DEBUG
+};
+
+/**
+ * Retrieves a set of flags indicating the CHRE optional features supported by
+ * the current implementation. The value returned by this function must be
+ * consistent for the entire duration of the nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_CAPABILITIES_* flags set.
+ *
+ * @since v1.10
+ */
+uint32_t chreGetCapabilities(void);
+
+/**
+ * Returns the maximum size in bytes of a message sent to the host.
+ * This function will always return a value greater than or equal to
+ * CHRE_MESSAGE_TO_HOST_MAX_SIZE. If the capability
+ * CHRE_CAPABILITIES_RELIABLE_MESSAGES is enabled, this function will
+ * return a value greater than or equal to 32000.
+ *
+ * On v1.9 or earlier platforms, this will always return CHRE_MESSAGE_TO_HOST_MAX_SIZE.
+ *
+ * @return The maximum message size in bytes.
+ *
+ * @since v1.10
+ */
+uint32_t chreGetMessageToHostMaxSize(void);
+
+/**
+ * Get the application ID.
+ *
+ * The application ID is set by the loader of the nanoapp. This is not
+ * assured to be unique among all nanoapps running in the system.
+ *
+ * @return The application ID.
+ */
+uint64_t chreGetAppId(void);
+
+/**
+ * Get the instance ID.
+ *
+ * The instance ID is the CHRE handle to this nanoapp. This is assured
+ * to be unique among all nanoapps running in the system, and to be
+ * different from the CHRE_INSTANCE_ID. This is the ID used to communicate
+ * between nanoapps.
+ *
+ * @return The instance ID
+ */
+uint32_t chreGetInstanceId(void);
+
+/**
+ * A method for logging information about the system.
+ *
+ * The chreLog logging activity alone must not cause host wake-ups. For
+ * example, logs could be buffered in internal memory when the host is asleep,
+ * and delivered when appropriate (e.g. the host wakes up). If done this way,
+ * the internal buffer is recommended to be large enough (at least a few KB), so
+ * that multiple messages can be buffered. When these logs are sent to the host,
+ * they are strongly recommended to be made visible under the tag 'CHRE' in
+ * logcat - a future version of the CHRE API may make this a hard requirement.
+ *
+ * A log entry can have a variety of levels (@see LogLevel). This function
+ * allows a variable number of arguments, in a printf-style format.
+ *
+ * A nanoapp needs to be able to rely upon consistent printf format
+ * recognition across any platform, and thus we establish formats which
+ * are required to be handled by every CHRE implementation. Some of the
+ * integral formats may seem obscure, but this API heavily uses types like
+ * uint32_t and uint16_t. The platform independent macros for those printf
+ * formats, like PRId32 or PRIx16, end up using some of these "obscure"
+ * formats on some platforms, and thus are required.
+ *
+ * For the initial N release, our emphasis is on correctly getting information
+ * into the log, and minimizing the requirements for CHRE implementations
+ * beyond that. We're not as concerned about how the information is visually
+ * displayed. As a result, there are a number of format sub-specifiers which
+ * are "OPTIONAL" for the N implementation. "OPTIONAL" in this context means
+ * that a CHRE implementation is allowed to essentially ignore the specifier,
+ * but it must understand the specifier enough in order to properly skip it.
+ *
+ * For a nanoapp author, an OPTIONAL format means you might not get exactly
+ * what you want on every CHRE implementation, but you will always get
+ * something valid.
+ *
+ * To be clearer, here's an example with the OPTIONAL 0-padding for integers
+ * for different hypothetical CHRE implementations.
+ * Compliant, chose to implement OPTIONAL format:
+ * chreLog(level, "%04x", 20) ==> "0014"
+ * Compliant, chose not to implement OPTIONAL format:
+ * chreLog(level, "%04x", 20) ==> "14"
+ * Non-compliant, discarded format because the '0' was assumed to be incorrect:
+ * chreLog(level, "%04x", 20) ==> ""
+ *
+ * Note that some of the OPTIONAL specifiers will probably become
+ * required in future APIs.
+ *
+ * We also have NOT_SUPPORTED specifiers. Nanoapp authors should not use any
+ * NOT_SUPPORTED specifiers, as unexpected things could happen on any given
+ * CHRE implementation. A CHRE implementation is allowed to support this
+ * (for example, when using shared code which already supports this), but
+ * nanoapp authors need to avoid these.
+ *
+ * Unless specifically noted as OPTIONAL or NOT_SUPPORTED, format
+ * (sub-)specifiers listed below are required.
+ *
+ * While all CHRE implementations must support chreLog(), some platform
+ * implementations may support enhanced logging functionality only possible
+ * through a macro. This improved functionality is supported through
+ * platform-specific customization of the log macros provided in
+ * chre/util/nanoapp/log.h. All nanoapps are recommended to use these log
+ * macros where possible, as they will fall back to chreLog() as needed.
+ *
+ * OPTIONAL format sub-specifiers:
+ * - '-' (left-justify within the given field width)
+ * - '+' (precede the result with a '+' sign if it is positive)
+ * - ' ' (precede the result with a blank space if no sign is going to be
+ * output)
+ * - '#' (For 'o', 'x' or 'X', precede output with "0", "0x" or "0X",
+ * respectively. For floating point, unconditionally output a decimal
+ * point.)
+ * - '0' (left pad the number with zeroes instead of spaces when <width>
+ * needs padding)
+ * - <width> (A number representing the minimum number of characters to be
+ * output, left-padding with blank spaces if needed to meet the
+ * minimum)
+ * - '.'<precision> (A number which has different meaning depending on context.)
+ * - Integer context: Minimum number of digits to output, padding with
+ * leading zeros if needed to meet the minimum.
+ * - 'f' context: Number of digits to output after the decimal
+ * point (to the right of it).
+ * - 's' context: Maximum number of characters to output.
+ *
+ * Integral format specifiers:
+ * - 'd' (signed)
+ * - 'u' (unsigned)
+ * - 'o' (octal)
+ * - 'x' (hexadecimal, lower case)
+ * - 'X' (hexadecimal, upper case)
+ *
+ * Integral format sub-specifiers (as prefixes to an above integral format):
+ * - 'hh' (char)
+ * - 'h' (short)
+ * - 'l' (long)
+ * - 'll' (long long)
+ * - 'z' (size_t)
+ * - 't' (ptrdiff_t)
+ *
+ * Other format specifiers:
+ * - 'f' (floating point)
+ * - 'c' (character)
+ * - 's' (character string, terminated by '\0')
+ * - 'p' (pointer)
+ * - '%' (escaping the percent sign (i.e. "%%" becomes "%"))
+ *
+ * NOT_SUPPORTED specifiers:
+ * - 'n' (output nothing, but fill in a given pointer with the number
+ * of characters written so far)
+ * - '*' (indicates that the width/precision value comes from one of the
+ * arguments to the function)
+ * - 'e', 'E' (scientific notation output)
+ * - 'g', 'G' (Shortest floating point representation)
+ *
+ * @param level The severity level for this message.
+ * @param formatStr Either the entirety of the message, or a printf-style
+ * format string of the format documented above.
+ * @param ... A variable number of arguments necessary for the given
+ * 'formatStr' (there may be no additional arguments for some 'formatStr's).
+ */
+CHRE_PRINTF_ATTR(2, 3)
+void chreLog(enum chreLogLevel level, const char *formatStr, ...);
+
+/**
+ * Get the system time.
+ *
+ * This returns a time in nanoseconds in reference to some arbitrary
+ * time in the past. This method is only useful for determining timing
+ * between events on the system, and is not useful for determining
+ * any sort of absolute time.
+ *
+ * This value must always increase (and must never roll over). This
+ * value has no meaning across CHRE reboots.
+ *
+ * @return The system time, in nanoseconds.
+ */
+uint64_t chreGetTime(void);
+
+/**
+ * Retrieves CHRE's current estimated offset between the local CHRE clock
+ * exposed in chreGetTime(), and the host-side clock exposed in the Android API
+ * SystemClock.elapsedRealtimeNanos(). This offset is formed as host time minus
+ * CHRE time, so that it can be added to the value returned by chreGetTime() to
+ * determine the current estimate of the host time.
+ *
+ * A call to this function must not require waking up the host and should return
+ * quickly.
+ *
+ * This function must always return a valid value from the earliest point that
+ * it can be called by a nanoapp. In other words, it is not valid to return
+ * some fixed/invalid value while waiting for the initial offset estimate to be
+ * determined - this initial offset must be ready before nanoapps are started.
+ *
+ * @return An estimate of the offset between CHRE's time returned in
+ * chreGetTime() and the time on the host given in the Android API
+ * SystemClock.elapsedRealtimeNanos(), accurate to within +/- 10
+ * milliseconds, such that adding this offset to chreGetTime() produces the
+ * estimated current time on the host. This value may change over time to
+ * account for drift, etc., so multiple calls to this API may produce
+ * different results.
+ *
+ * @since v1.1
+ */
+int64_t chreGetEstimatedHostTimeOffset(void);
+
+/**
+ * Convenience function to retrieve CHRE's estimate of the current time on the
+ * host, corresponding to the Android API SystemClock.elapsedRealtimeNanos().
+ *
+ * @return An estimate of the current time on the host, accurate to within
+ * +/- 10 milliseconds. This estimate is *not* guaranteed to be
+ * monotonically increasing, and may move backwards as a result of receiving
+ * new information from the host.
+ *
+ * @since v1.1
+ */
+static inline uint64_t chreGetEstimatedHostTime(void) {
+ int64_t offset = chreGetEstimatedHostTimeOffset();
+ uint64_t time = chreGetTime();
+
+ // Just casting time to int64_t and adding the (potentially negative) offset
+ // should be OK under most conditions, but this way avoids issues if
+ // time >= 2^63, which is technically allowed since we don't specify a start
+ // value for chreGetTime(), though one would assume 0 is roughly boot time.
+ if (offset >= 0) {
+ time += (uint64_t) offset;
+ } else {
+ // Assuming chreGetEstimatedHostTimeOffset() is implemented properly,
+ // this will never underflow, because offset = hostTime - chreTime,
+ // and both times are monotonically increasing (e.g. when determining
+ // the offset, if hostTime is 0 and chreTime is 100 we'll have
+ // offset = -100, but chreGetTime() will always return >= 100 after that
+ // point).
+ time -= (uint64_t) (offset * -1);
+ }
+
+ return time;
+}
+
+/**
+ * Set a timer.
+ *
+ * When the timer fires, nanoappHandleEvent will be invoked with
+ * CHRE_EVENT_TIMER and with the given 'cookie'.
+ *
+ * A CHRE implementation is required to provide at least 32
+ * timers. However, there's no assurance there will be any available
+ * for any given nanoapp (if it's loaded late, etc).
+ *
+ * @param duration Time, in nanoseconds, before the timer fires.
+ * @param cookie Argument that will be sent to nanoappHandleEvent upon the
+ * timer firing. This is allowed to be NULL and does not need to be
+ * a valid pointer (assuming the nanoappHandleEvent code is expecting such).
+ * @param oneShot If true, the timer will just fire once. If false, the
+ * timer will continue to refire every 'duration', until this timer is
+ * canceled (@see chreTimerCancel).
+ *
+ * @return The timer ID. If the system is unable to set a timer
+ * (no more available timers, etc.) then CHRE_TIMER_INVALID will
+ * be returned.
+ *
+ * @see nanoappHandleEvent
+ */
+uint32_t chreTimerSet(uint64_t duration, const void *cookie, bool oneShot);
+
+/**
+ * Cancel a timer.
+ *
+ * After this method returns, the CHRE assures there will be no more
+ * events sent from this timer, and any enqueued events from this timer
+ * will need to be evicted from the queue by the CHRE.
+ *
+ * @param timerId A timer ID obtained by this nanoapp via chreTimerSet().
+ * @return true if the timer was cancelled, false otherwise. We may
+ * fail to cancel the timer if it's a one shot which (just) fired,
+ * or if the given timer ID is not owned by the calling app.
+ */
+bool chreTimerCancel(uint32_t timerId);
+
+/**
+ * Terminate this nanoapp.
+ *
+ * This takes effect immediately.
+ *
+ * The CHRE will no longer execute this nanoapp. The CHRE will not invoke
+ * nanoappEnd(), nor will it call any memory free callbacks in the nanoapp.
+ *
+ * The CHRE will unload/evict this nanoapp's code.
+ *
+ * @param abortCode A value indicating the reason for aborting. (Note that
+ * in this version of the API, there is no way for anyone to access this
+ * code, but future APIs may expose it.)
+ * @return Never. This method does not return, as the CHRE stops nanoapp
+ * execution immediately.
+ */
+void chreAbort(uint32_t abortCode) CHRE_NO_RETURN;
+
+/**
+ * Allocate a given number of bytes from the system heap.
+ *
+ * The nanoapp is required to free this memory via chreHeapFree() prior to
+ * the nanoapp ending.
+ *
+ * While the CHRE implementation is required to free up heap resources of
+ * a nanoapp when unloading it, future requirements and tests focused on
+ * nanoapps themselves may check for memory leaks, and will require nanoapps
+ * to properly manage their heap resources.
+ *
+ * @param bytes The number of bytes requested.
+ * @return A pointer to 'bytes' contiguous bytes of heap memory, or NULL
+ * if the allocation could not be performed. This pointer must be suitably
+ * aligned for any kind of variable.
+ *
+ * @see chreHeapFree.
+ */
+CHRE_MALLOC_ATTR
+void *chreHeapAlloc(uint32_t bytes);
+
+/**
+ * Free a heap allocation.
+ *
+ * This allocation must be from a value returned from a chreHeapAlloc() call
+ * made by this nanoapp. In other words, it is illegal to free memory
+ * allocated by another nanoapp (or the CHRE).
+ *
+ * @param ptr 'ptr' is required to be a value returned from chreHeapAlloc().
+ * Note that since chreHeapAlloc can return NULL, CHRE
+ * implementations must safely handle 'ptr' being NULL.
+ *
+ * @see chreHeapAlloc.
+ */
+void chreHeapFree(void *ptr);
+
+/**
+ * Logs the nanoapp's debug data into debug dumps.
+ *
+ * A debug dump is a string representation of information that can be used to
+ * diagnose and debug issues. While chreLog() is useful for logging events as
+ * they happen, the debug dump is a complementary function typically used to
+ * output a snapshot of a nanoapp's state, history, vital statistics, etc. The
+ * CHRE framework is required to pass this information to the debug method in
+ * the Context Hub HAL, where it can be captured in Android bugreports, etc.
+ *
+ * This function must only be called while handling CHRE_DEBUG_DUMP_EVENT,
+ * otherwise it will have no effect. A nanoapp can call this function multiple
+ * times while handling the event. If the resulting formatted string from a
+ * single call to this function is longer than CHRE_DEBUG_DUMP_MINIMUM_MAX_SIZE
+ * characters, it may get truncated.
+ *
+ * @param formatStr A printf-style format string of the format documented in
+ * chreLog().
+ * @param ... A variable number of arguments necessary for the given 'formatStr'
+ * (there may be no additional arguments for some 'formatStr's).
+ *
+ * @see chreConfigureDebugDumpEvent
+ * @see chreLog
+ *
+ * @since v1.4
+ */
+CHRE_PRINTF_ATTR(1, 2)
+void chreDebugDumpLog(const char *formatStr, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_RE_H_ */
+
diff --git a/chre_api/legacy/v1_10/chre/sensor.h b/chre_api/legacy/v1_10/chre/sensor.h
new file mode 100644
index 0000000..551803e
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/sensor.h
@@ -0,0 +1,1132 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_SENSOR_H_
+#define _CHRE_SENSOR_H_
+
+/**
+ * @file
+ * API dealing with sensor interaction in the Context Hub Runtime
+ * Environment.
+ *
+ * This includes the definition of our sensor types and the ability to
+ * configure them for receiving events.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <chre/common.h>
+#include <chre/event.h>
+#include <chre/sensor_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Base value for all of the data events for sensors.
+ *
+ * The value for a data event FOO is
+ * CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_FOO
+ *
+ * This allows for easy mapping, and also explains why there are gaps
+ * in our values since we don't have all possible sensor types assigned.
+ */
+#define CHRE_EVENT_SENSOR_DATA_EVENT_BASE CHRE_EVENT_SENSOR_FIRST_EVENT
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in SI units (m/s^2) and measure the acceleration applied to
+ * the device.
+ */
+#define CHRE_EVENT_SENSOR_ACCELEROMETER_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_ACCELEROMETER)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorOccurrenceData
+ *
+ * Since this is a one-shot sensor, after this event is delivered to the
+ * nanoapp, the sensor automatically goes into DONE mode. Sensors of this
+ * type must be configured with a ONE_SHOT mode.
+ */
+#define CHRE_EVENT_SENSOR_INSTANT_MOTION_DETECT_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorOccurrenceData
+ *
+ * Since this is a one-shot sensor, after this event is delivered to the
+ * nanoapp, the sensor automatically goes into DONE mode. Sensors of this
+ * type must be configured with a ONE_SHOT mode.
+ */
+#define CHRE_EVENT_SENSOR_STATIONARY_DETECT_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_STATIONARY_DETECT)
+
+/**
+ * nanoappHandleEvent argument: struct struct chreSensorOccurrenceData
+ *
+ * Since this is a one-shot sensor, after this event is delivered to the
+ * nanoapp, the sensor automatically goes into DONE mode. Sensors of this
+ * type must be configured with a ONE_SHOT mode.
+ */
+#define CHRE_EVENT_SENSOR_SIGNIFICANT_MOTION_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_SIGNIFICANT_MOTION)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in radians/second and measure the rate of rotation
+ * around the X, Y and Z axis.
+ */
+#define CHRE_EVENT_SENSOR_GYROSCOPE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_GYROSCOPE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in micro-Tesla (uT) and measure the geomagnetic
+ * field in the X, Y and Z axis.
+ */
+#define CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The data can be interpreted using the 'pressure' field within 'readings'.
+ * This value is in hectopascals (hPa).
+ */
+#define CHRE_EVENT_SENSOR_PRESSURE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_PRESSURE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The data can be interpreted using the 'light' field within 'readings'.
+ * This value is in SI lux units.
+ */
+#define CHRE_EVENT_SENSOR_LIGHT_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_LIGHT)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorByteData
+ *
+ * The data is interpreted from the following fields in 'readings':
+ * o 'isNear': If set to 1, we are nearby (on the order of centimeters);
+ * if set to 0, we are far. The meaning of near/far in this field must be
+ * consistent with the Android definition.
+ * o 'invalid': If set to 1, this is not a valid reading of this data.
+ * As of CHRE API v1.2, this field is deprecated and must always be set to
+ * 0. If an invalid reading is generated by the sensor hardware, it must
+ * be dropped and not delivered to any nanoapp.
+ *
+ * In prior versions of the CHRE API, there can be an invalid event generated
+ * upon configuring this sensor. Thus, the 'invalid' field must be checked on
+ * the first event before interpreting 'isNear'.
+ */
+#define CHRE_EVENT_SENSOR_PROXIMITY_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_PROXIMITY)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorOccurrenceData
+ *
+ * This data is generated every time a step is taken by the user.
+ *
+ * This is backed by the same algorithm that feeds Android's
+ * SENSOR_TYPE_STEP_DETECTOR, and therefore sacrifices some accuracy to target
+ * an update latency of under 2 seconds.
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_STEP_DETECT_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_STEP_DETECT)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorUint64Data
+ *
+ * The value of the data is the cumulative number of steps taken by the user
+ * since the last reboot while the sensor is active. This data is generated
+ * every time a step is taken by the user.
+ *
+ * This is backed by the same algorithm that feeds Android's
+ * SENSOR_TYPE_STEP_COUNTER, and therefore targets high accuracy with under
+ * 10 seconds of update latency.
+ *
+ * @since v1.5
+ */
+#define CHRE_EVENT_SENSOR_STEP_COUNTER_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_STEP_COUNTER)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The value of the data is the measured hinge angle between 0 and 360 degrees
+ * inclusive.
+ *
+ * This is backed by the same algorithm that feeds Android's
+ * SENSOR_TYPE_HINGE_ANGLE.
+ *
+ * @since v1.5
+ */
+#define CHRE_EVENT_SENSOR_HINGE_ANGLE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_HINGE_ANGLE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in SI units (m/s^2) and measure the acceleration applied to
+ * the device.
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in radians/second and measure the rate of rotation
+ * around the X, Y and Z axis.
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x', 'y', and 'z' fields within
+ * 'readings', or by the 3D array 'v' (v[0] == x; v[1] == y; v[2] == z).
+ *
+ * All values are in micro-Tesla (uT) and measure the geomagnetic
+ * field in the X, Y and Z axis.
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_GEOMAGNETIC_FIELD_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The data can be interpreted using the 'temperature' field within 'readings'.
+ * This value is in degrees Celsius.
+ */
+#define CHRE_EVENT_SENSOR_ACCELEROMETER_TEMPERATURE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The data can be interpreted using the 'temperature' field within 'readings'.
+ * This value is in degrees Celsius.
+ */
+#define CHRE_EVENT_SENSOR_GYROSCOPE_TEMPERATURE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFloatData
+ *
+ * The data can be interpreted using the 'temperature' field within 'readings'.
+ * This value is in degrees Celsius.
+ */
+#define CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_TEMPERATURE_DATA \
+ (CHRE_EVENT_SENSOR_DATA_EVENT_BASE + CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE)
+
+/**
+ * First value for sensor events which are not data from the sensor.
+ *
+ * Unlike the data event values, these other event values don't have any
+ * mapping to sensor types.
+ */
+#define CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE \
+ (CHRE_EVENT_SENSOR_FIRST_EVENT + 0x0100)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorSamplingStatusEvent
+ *
+ * Indicates that the interval and/or the latency which this sensor is
+ * sampling at has changed.
+ */
+#define CHRE_EVENT_SENSOR_SAMPLING_CHANGE \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 0)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x_bias', 'y_bias', and 'z_bias'
+ * field within 'readings', or by the 3D array 'bias' (bias[0] == x_bias;
+ * bias[1] == y_bias; bias[2] == z_bias). Bias is subtracted from uncalibrated
+ * data to generate calibrated data.
+ *
+ * All values are in radians/second and measure the rate of rotation
+ * around the X, Y and Z axis.
+ *
+ * If bias delivery is supported, this event is generated by default when
+ * chreSensorConfigure is called to enable for the sensor of type
+ * CHRE_SENSOR_TYPE_GYROSCOPE, or if bias delivery is explicitly enabled
+ * through chreSensorConfigureBiasEvents() for the sensor.
+ */
+#define CHRE_EVENT_SENSOR_GYROSCOPE_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 1)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x_bias', 'y_bias', and 'z_bias'
+ * field within 'readings', or by the 3D array 'bias' (bias[0] == x_bias;
+ * bias[1] == y_bias; bias[2] == z_bias). Bias is subtracted from uncalibrated
+ * data to generate calibrated data.
+ *
+ * All values are in micro-Tesla (uT) and measure the geomagnetic
+ * field in the X, Y and Z axis.
+ *
+ * If bias delivery is supported, this event is generated by default when
+ * chreSensorConfigure is called to enable for the sensor of type
+ * CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD, or if bias delivery is explicitly enabled
+ * through chreSensorConfigureBiasEvents() for the sensor.
+ */
+#define CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 2)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data can be interpreted using the 'x_bias', 'y_bias', and 'z_bias'
+ * field within 'readings', or by the 3D array 'bias' (bias[0] == x_bias;
+ * bias[1] == y_bias; bias[2] == z_bias). Bias is subtracted from uncalibrated
+ * data to generate calibrated data.
+ *
+ * All values are in SI units (m/s^2) and measure the acceleration applied to
+ * the device.
+ *
+ * If bias delivery is supported, this event is generated by default when
+ * chreSensorConfigure is called to enable for the sensor of type
+ * CHRE_SENSOR_TYPE_ACCELEROMETER, or if bias delivery is explicitly enabled
+ * through chreSensorConfigureBiasEvents() for the sensor.
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 3)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorFlushCompleteEvent
+ *
+ * An event indicating that a flush request made by chreSensorFlushAsync has
+ * completed.
+ *
+ * @see chreSensorFlushAsync
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_FLUSH_COMPLETE \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 4)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data of this event is the same as that of
+ * CHRE_EVENT_SENSOR_GYROSCOPE_BIAS_INFO, except the sensorHandle field of
+ * chreSensorDataHeader contains the handle of the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE.
+ *
+ * This event is only generated if the bias reporting is explicitly enabled
+ * for a nanoapp through chreSensorConfigureBiasEvents() for the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE.
+ *
+ * @see CHRE_EVENT_SENSOR_GYROSCOPE_BIAS_INFO
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 5)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data of this event is the same as that of
+ * CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_BIAS_INFO, except the sensorHandle field
+ * of chreSensorDataHeader contains the handle of the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD.
+ *
+ * This event is only generated if the bias reporting is explicitly enabled
+ * for a nanoapp through chreSensorConfigureBiasEvents() for the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD.
+ *
+ * @see CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_BIAS_INFO
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_GEOMAGNETIC_FIELD_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 6)
+
+/**
+ * nanoappHandleEvent argument: struct chreSensorThreeAxisData
+ *
+ * The data of this event is the same as that of
+ * CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO, except the sensorHandle field
+ * of chreSensorDataHeader contains the handle of the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER.
+ *
+ * This event is only generated if the bias reporting is explicitly enabled
+ * for a nanoapp through chreSensorConfigureBiasEvents for the sensor of type
+ * CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER.
+ *
+ * @see CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO
+ *
+ * @since v1.3
+ */
+#define CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_BIAS_INFO \
+ (CHRE_EVENT_SENSOR_OTHER_EVENTS_BASE + 7)
+
+#if CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_BIAS_INFO > \
+ CHRE_EVENT_SENSOR_LAST_EVENT
+#error Too many sensor events.
+#endif
+
+/**
+ * Value indicating we want the smallest possible latency for a sensor.
+ *
+ * This literally translates to 0 nanoseconds for the chreSensorConfigure()
+ * argument. While we won't get exactly 0 nanoseconds, the CHRE will
+ * queue up this event As Soon As Possible.
+ */
+#define CHRE_SENSOR_LATENCY_ASAP UINT64_C(0)
+
+/**
+ * Special value indicating non-importance, or non-applicability of the sampling
+ * interval.
+ *
+ * @see chreSensorConfigure
+ * @see chreSensorSamplingStatus
+ */
+#define CHRE_SENSOR_INTERVAL_DEFAULT UINT64_C(-1)
+
+/**
+ * Special value indicating non-importance of the latency.
+ *
+ * @see chreSensorConfigure
+ * @see chreSensorSamplingStatus
+ */
+#define CHRE_SENSOR_LATENCY_DEFAULT UINT64_C(-1)
+
+/**
+ * A sensor index value indicating that it is the default sensor.
+ *
+ * @see chreSensorFind
+ */
+#define CHRE_SENSOR_INDEX_DEFAULT UINT8_C(0)
+
+/**
+ * Special value indicating non-importance of the batch interval.
+ *
+ * @see chreSensorConfigureWithBatchInterval
+ */
+#define CHRE_SENSOR_BATCH_INTERVAL_DEFAULT UINT64_C(-1)
+
+// This is used to define elements of enum chreSensorConfigureMode.
+#define CHRE_SENSOR_CONFIGURE_RAW_POWER_ON (1 << 0)
+
+// This is used to define elements of enum chreSensorConfigureMode.
+#define CHRE_SENSOR_CONFIGURE_RAW_REPORT_CONTINUOUS (1 << 1)
+
+// This is used to define elements of enum chreSensorConfigureMode.
+#define CHRE_SENSOR_CONFIGURE_RAW_REPORT_ONE_SHOT (2 << 1)
+
+/**
+ * The maximum amount of time allowed to elapse between the call to
+ * chreSensorFlushAsync() and when CHRE_EVENT_SENSOR_FLUSH_COMPLETE is delivered
+ * to the nanoapp on a successful flush.
+ */
+#define CHRE_SENSOR_FLUSH_COMPLETE_TIMEOUT_NS (5 * CHRE_NSEC_PER_SEC)
+
+/**
+ * Modes we can configure a sensor to use.
+ *
+ * Our mode will affect not only how/if we receive events, but
+ * also whether or not the sensor will be powered on our behalf.
+ *
+ * @see chreSensorConfigure
+ */
+enum chreSensorConfigureMode {
+ /**
+ * Get events from the sensor.
+ *
+ * Power: Turn on if not already on.
+ * Reporting: Continuous. Send each new event as it comes (subject to
+ * batching and latency).
+ */
+ CHRE_SENSOR_CONFIGURE_MODE_CONTINUOUS =
+ (CHRE_SENSOR_CONFIGURE_RAW_POWER_ON |
+ CHRE_SENSOR_CONFIGURE_RAW_REPORT_CONTINUOUS),
+
+ /**
+ * Get a single event from the sensor and then become DONE.
+ *
+ * Once the event is sent, the sensor automatically
+ * changes to CHRE_SENSOR_CONFIGURE_MODE_DONE mode.
+ *
+ * Power: Turn on if not already on.
+ * Reporting: One shot. Send the next event and then be DONE.
+ */
+ CHRE_SENSOR_CONFIGURE_MODE_ONE_SHOT =
+ (CHRE_SENSOR_CONFIGURE_RAW_POWER_ON |
+ CHRE_SENSOR_CONFIGURE_RAW_REPORT_ONE_SHOT),
+
+ /**
+ * Get events from a sensor that are generated for any client in the system.
+ *
+ * This is considered passive because the sensor will not be powered on for
+ * the sake of our nanoapp. If and only if another client in the system has
+ * requested this sensor power on will we get events.
+ *
+ * This can be useful for something which is interested in seeing data, but
+ * not interested enough to be responsible for powering on the sensor.
+ *
+ * Power: Do not power the sensor on our behalf.
+ * Reporting: Continuous. Send each event as it comes.
+ */
+ CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_CONTINUOUS =
+ CHRE_SENSOR_CONFIGURE_RAW_REPORT_CONTINUOUS,
+
+ /**
+ * Get a single event from a sensor that is generated for any client in the
+ * system.
+ *
+ * See CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_CONTINUOUS for more details on
+ * what the "passive" means.
+ *
+ * Power: Do not power the sensor on our behalf.
+ * Reporting: One shot. Send only the next event and then be DONE.
+ */
+ CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_ONE_SHOT =
+ CHRE_SENSOR_CONFIGURE_RAW_REPORT_ONE_SHOT,
+
+ /**
+ * Indicate we are done using this sensor and no longer interested in it.
+ *
+ * See chreSensorConfigure for more details on expressing interest or
+ * lack of interest in a sensor.
+ *
+ * Power: Do not power the sensor on our behalf.
+ * Reporting: None.
+ */
+ CHRE_SENSOR_CONFIGURE_MODE_DONE = 0,
+};
+
+/**
+ * A structure containing information about a Sensor.
+ *
+ * See documentation of individual fields below.
+ */
+struct chreSensorInfo {
+ /**
+ * The name of the sensor.
+ *
+ * A text name, useful for logging/debugging, describing the Sensor. This
+ * is not assured to be unique (i.e. there could be multiple sensors with
+ * the name "Temperature").
+ *
+ * CHRE implementations may not set this as NULL. An empty
+ * string, while discouraged, is legal.
+ */
+ const char *sensorName;
+
+ /**
+ * One of the CHRE_SENSOR_TYPE_* defines above.
+ */
+ uint8_t sensorType;
+
+ /**
+ * Flag indicating if this sensor is on-change.
+ *
+ * An on-change sensor only generates events when underlying state
+ * changes. This has the same meaning as on-change does in the Android
+ * Sensors HAL. See sensors.h for much more details.
+ *
+ * A value of 1 indicates this is on-change. 0 indicates this is not
+ * on-change.
+ */
+ uint8_t isOnChange : 1;
+
+ /**
+ * Flag indicating if this sensor is one-shot.
+ *
+ * A one-shot sensor only triggers a single event, and then automatically
+ * disables itself.
+ *
+ * A value of 1 indicates this is one-shot. 0 indicates this is not
+ * on-change.
+ */
+ uint8_t isOneShot : 1;
+
+ /**
+ * Flag indicating if this sensor supports reporting bias info events.
+ *
+ * This field will be set to 0 when running on CHRE API versions prior to
+ * v1.3, but must be ignored (i.e. does not mean bias info event is not
+ * supported).
+ *
+ * @see chreSensorConfigureBiasEvents
+ *
+ * @since v1.3
+ */
+ uint8_t reportsBiasEvents : 1;
+
+ /**
+ * Flag indicating if this sensor supports passive mode requests.
+ *
+ * This field will be set to 0 when running on CHRE API versions prior to
+ * v1.4, and must be ignored (i.e. does not mean passive mode requests are
+ * not supported).
+ *
+ * @see chreSensorConfigure
+ *
+ * @since v1.4
+ */
+ uint8_t supportsPassiveMode : 1;
+
+ uint8_t unusedFlags : 4;
+
+ /**
+ * The minimum sampling interval supported by this sensor, in nanoseconds.
+ *
+ * Requests to chreSensorConfigure with a lower interval than this will
+ * fail. If the sampling interval is not applicable to this sensor, this
+ * will be set to CHRE_SENSOR_INTERVAL_DEFAULT.
+ *
+ * This field will be set to 0 when running on CHRE API versions prior to
+ * v1.1, indicating that the minimum interval is not known.
+ *
+ * @since v1.1
+ */
+ uint64_t minInterval;
+
+ /**
+ * Uniquely identifies the sensor for a given type. A value of 0 indicates
+ * that this is the "default" sensor, which is returned by
+ * chreSensorFindDefault().
+ *
+ * The sensor index of a given type must be stable across boots (i.e. must
+ * not change), and a different sensor of the same type must have different
+ * sensor index values, and the set of sensorIndex values for a given sensor
+ * type must be continuguous.
+ *
+ * @since v1.5
+ */
+ uint8_t sensorIndex;
+};
+
+/**
+ * The status of a sensor's sampling configuration.
+ */
+struct chreSensorSamplingStatus {
+ /**
+ * The interval, in nanoseconds, at which sensor data is being sampled at.
+ * This should be used by nanoapps to determine the rate at which samples
+ * will be generated and not to indicate what the sensor is truly sampling
+ * at since resampling may occur to limit incoming data.
+ *
+ * If this is CHRE_SENSOR_INTERVAL_DEFAULT, then a sampling interval
+ * isn't meaningful for this sensor.
+ *
+ * Note that if 'enabled' is false, this value is not meaningful.
+ */
+ uint64_t interval;
+
+ /**
+ * The latency, in nanoseconds, at which the sensor is now reporting.
+ *
+ * If this is CHRE_SENSOR_LATENCY_DEFAULT, then a latency
+ * isn't meaningful for this sensor.
+ *
+ * The effective batch interval can be derived from this value by
+ * adding the current sampling interval.
+ *
+ * Note that if 'enabled' is false, this value is not meaningful.
+ */
+ uint64_t latency;
+
+ /**
+ * True if the sensor is actively powered and sampling; false otherwise.
+ */
+ bool enabled;
+};
+
+/**
+ * The nanoappHandleEvent argument for CHRE_EVENT_SENSOR_SAMPLING_CHANGE.
+ *
+ * Note that only at least one of 'interval' or 'latency' must be
+ * different than it was prior to this event. Thus, one of these
+ * fields may be (but doesn't need to be) the same as before.
+ */
+struct chreSensorSamplingStatusEvent {
+ /**
+ * The handle of the sensor which has experienced a change in sampling.
+ */
+ uint32_t sensorHandle;
+
+ /**
+ * The new sampling status.
+ *
+ * At least one of the field in this struct will be different from
+ * the previous sampling status event.
+ */
+ struct chreSensorSamplingStatus status;
+};
+
+/**
+ * The nanoappHandleEvent argument for CHRE_EVENT_SENSOR_FLUSH_COMPLETE.
+ *
+ * @see chreSensorFlushAsync
+ *
+ * @since v1.3
+ */
+struct chreSensorFlushCompleteEvent {
+ /**
+ * The handle of the sensor which a flush was completed.
+ */
+ uint32_t sensorHandle;
+
+ /**
+ * Populated with a value from enum {@link #chreError}, indicating whether
+ * the flush failed, and if so, provides the cause of the failure.
+ */
+ uint8_t errorCode;
+
+ /**
+ * Reserved for future use. Set to 0.
+ */
+ uint8_t reserved[3];
+
+ /**
+ * Set to the cookie parameter given to chreSensorFlushAsync.
+ */
+ const void *cookie;
+};
+
+/**
+ * Find the default sensor for a given sensor type.
+ *
+ * @param sensorType One of the CHRE_SENSOR_TYPE_* constants.
+ * @param handle If a sensor is found, then the memory will be filled with
+ * the value for the sensor's handle. This argument must be non-NULL.
+ * @return true if a sensor was found, false otherwise.
+ */
+bool chreSensorFindDefault(uint8_t sensorType, uint32_t *handle);
+
+/**
+ * Finds a sensor of a given index and sensor type.
+ *
+ * For CHRE implementations that support multiple sensors of the same sensor
+ * type, this method can be used to get the non-default sensor(s). The default
+ * sensor, as defined in the chreSensorFindDefault(), will be returned if
+ * a sensor index of zero is specified.
+ *
+ * A simple example of iterating all available sensors of a given type is
+ * provided here:
+ *
+ * uint32_t handle;
+ * for (uint8_t i = 0; chreSensorFind(sensorType, i, &handle); i++) {
+ * chreLog(CHRE_LOG_INFO,
+ * "Found sensor index %" PRIu8 ", which has handle %" PRIu32,
+ * i, handle);
+ * }
+ *
+ * If this method is invoked for CHRE versions prior to v1.5, invocations with
+ * sensorIndex value of 0 will be equivalent to using chreSensorFindDefault, and
+ * if sensorIndex is non-zero will return false.
+ *
+ * In cases where multiple sensors are supported in both the Android sensors
+ * framework and CHRE, the sensorName of the chreSensorInfo struct for a given
+ * sensor instance must match exactly with that of the
+ * android.hardware.Sensor#getName() return value. This can be used to match a
+ * sensor instance between the Android and CHRE sensors APIs.
+ *
+ * @param sensorType One of the CHRE_SENSOR_TYPE_* constants.
+ * @param sensorIndex The index of the desired sensor.
+ * @param handle If a sensor is found, then the memory will be filled with
+ * the value for the sensor's handle. This argument must be non-NULL.
+ * @return true if a sensor was found, false otherwise.
+ *
+ * @since v1.5
+ */
+bool chreSensorFind(uint8_t sensorType, uint8_t sensorIndex, uint32_t *handle);
+
+/**
+ * Get the chreSensorInfo struct for a given sensor.
+ *
+ * @param sensorHandle The sensor handle, as obtained from
+ * chreSensorFindDefault() or passed to nanoappHandleEvent().
+ * @param info If the sensor is valid, then this memory will be filled with
+ * the SensorInfo contents for this sensor. This argument must be
+ * non-NULL.
+ * @return true if the senor handle is valid and 'info' was filled in;
+ * false otherwise.
+ */
+bool chreGetSensorInfo(uint32_t sensorHandle, struct chreSensorInfo *info);
+
+/**
+ * Get the chreSensorSamplingStatus struct for a given sensor.
+ *
+ * Note that this may be different from what was requested in
+ * chreSensorConfigure(), for multiple reasons. It's possible that the sensor
+ * does not exactly support the interval requested in chreSensorConfigure(), so
+ * a faster one was chosen.
+ *
+ * It's also possible that there is another user of this sensor who has
+ * requested a faster interval and/or lower latency. This latter scenario
+ * should be noted, because it means the sensor rate can change due to no
+ * interaction from this nanoapp. Note that the
+ * CHRE_EVENT_SENSOR_SAMPLING_CHANGE event will trigger in this case, so it's
+ * not necessary to poll for such a change.
+ *
+ * This function must return a valid status if the provided sensor is being
+ * actively sampled by a nanoapp and a CHRE_EVENT_SENSOR_SAMPLING_CHANGE has
+ * been delivered indicating their request has taken effect. It is not required
+ * to return a valid status if no nanoapp is actively sampling the sensor.
+ *
+ * @param sensorHandle The sensor handle, as obtained from
+ * chreSensorFindDefault() or passed to nanoappHandleEvent().
+ * @param status If the sensor is actively enabled by a nanoapp, then this
+ * memory must be filled with the sampling status contents for this sensor.
+ * This argument must be non-NULL.
+ * @return true if the sensor handle is valid and 'status' was filled in;
+ * false otherwise.
+ */
+bool chreGetSensorSamplingStatus(uint32_t sensorHandle,
+ struct chreSensorSamplingStatus *status);
+
+/**
+ * Configures a given sensor at a specific interval and latency and mode.
+ *
+ * If this sensor's chreSensorInfo has isOneShot set to 1,
+ * then the mode must be one of the ONE_SHOT modes, or this method will fail.
+ *
+ * The CHRE wants to power as few sensors as possible, in keeping with its
+ * low power design. As such, it only turns on sensors when there are clients
+ * actively interested in that sensor data, and turns off sensors as soon as
+ * there are no clients interested in them. Calling this method generally
+ * indicates an interest, and using CHRE_SENSOR_CONFIGURE_MODE_DONE shows
+ * when we are no longer interested.
+ *
+ * Thus, each initial Configure of a sensor (per nanoapp) needs to eventually
+ * have a DONE call made, either directly or on its behalf. Subsequent calls
+ * to a Configure method within the same nanoapp, when there has been no DONE
+ * in between, still only require a single DONE call.
+ *
+ * For example, the following is valid usage:
+ * <code>
+ * chreSensorConfigure(myHandle, mode, interval0, latency0);
+ * [...]
+ * chreSensorConfigure(myHandle, mode, interval1, latency0);
+ * [...]
+ * chreSensorConfigure(myHandle, mode, interval1, latency1);
+ * [...]
+ * chreSensorConfigureModeOnly(myHandle, CHRE_SENSOR_CONFIGURE_MODE_DONE);
+ * </code>
+ *
+ * The first call to Configure is the one which creates the requirement
+ * to eventually call with DONE. The subsequent calls are just changing the
+ * interval/latency. They have not changed the fact that this nanoapp is
+ * still interested in output from the sensor 'myHandle'. Thus, only one
+ * single call for DONE is needed.
+ *
+ * There is a special case. One-shot sensors, sensors which
+ * just trigger a single event and never trigger again, implicitly go into
+ * DONE mode after that single event triggers. Thus, the
+ * following are legitimate usages:
+ * <code>
+ * chreSensorConfigure(myHandle, MODE_ONE_SHOT, interval, latency);
+ * [...]
+ * [myHandle triggers an event]
+ * [no need to configure to DONE].
+ * </code>
+ *
+ * And:
+ * <code>
+ * chreSensorConfigure(myHandle, MODE_ONE_SHOT, interval, latency);
+ * [...]
+ * chreSensorConfigureModeOnly(myHandle, MODE_DONE);
+ * [we cancelled myHandle before it ever triggered an event]
+ * </code>
+ *
+ * Note that while PASSIVE modes, by definition, don't express an interest in
+ * powering the sensor, DONE is still necessary to silence the event reporting.
+ * Starting with CHRE API v1.4, for sensors that do not support passive mode, a
+ * request with mode set to CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_CONTINUOUS or
+ * CHRE_SENSOR_CONFIGURE_MODE_PASSIVE_ONE_SHOT will be rejected. CHRE API
+ * versions 1.3 and older implicitly assume that passive mode is supported
+ * across all sensors, however this is not necessarily the case. Clients can
+ * call chreSensorInfo to identify whether a sensor supports passive mode.
+ *
+ * When a calibrated sensor (e.g. CHRE_SENSOR_TYPE_ACCELEROMETER) is
+ * successfully enabled through this method and if bias delivery is supported,
+ * by default CHRE will start delivering bias events for the sensor
+ * (e.g. CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO) to the nanoapp. If the
+ * nanoapp does not wish to receive these events, they can be disabled through
+ * chreSensorConfigureBiasEvents after enabling the sensor.
+ *
+ * @param sensorHandle The handle to the sensor, as obtained from
+ * chreSensorFindDefault().
+ * @param mode The mode to use. See descriptions within the
+ * chreSensorConfigureMode enum.
+ * @param interval The interval, in nanoseconds, at which we want events from
+ * the sensor. On success, the sensor will be set to 'interval', or a value
+ * less than 'interval'. There is a special value
+ * CHRE_SENSOR_INTERVAL_DEFAULT, in which we don't express a preference for
+ * the interval, and allow the sensor to choose what it wants. Note that
+ * due to batching, we may receive events less frequently than
+ * 'interval'.
+ * @param latency The maximum latency, in nanoseconds, allowed before the
+ * CHRE begins delivery of an event. This will control how many events
+ * can be queued by the sensor before requiring a delivery event.
+ * Latency is defined as the "timestamp when event is queued by the CHRE"
+ * minus "timestamp of oldest unsent data reading".
+ * There is a special value CHRE_SENSOR_LATENCY_DEFAULT, in which we don't
+ * express a preference for the latency, and allow the sensor to choose what
+ * it wants.
+ * Note that there is no assurance of how long it will take an event to
+ * get through a CHRE's queueing system, and thus there is no ability to
+ * request a minimum time from the occurrence of a phenomenon to when the
+ * nanoapp receives the information. The current CHRE API has no
+ * real-time elements, although future versions may introduce some to
+ * help with this issue.
+ * @return true if the configuration succeeded, false otherwise.
+ *
+ * @see chreSensorConfigureMode
+ * @see chreSensorFindDefault
+ * @see chreSensorInfo
+ * @see chreSensorConfigureBiasEvents
+ */
+bool chreSensorConfigure(uint32_t sensorHandle,
+ enum chreSensorConfigureMode mode,
+ uint64_t interval, uint64_t latency);
+
+/**
+ * Short cut for chreSensorConfigure where we only want to configure the mode
+ * and do not care about interval/latency.
+ *
+ * @see chreSensorConfigure
+ */
+static inline bool chreSensorConfigureModeOnly(
+ uint32_t sensorHandle, enum chreSensorConfigureMode mode) {
+ return chreSensorConfigure(sensorHandle,
+ mode,
+ CHRE_SENSOR_INTERVAL_DEFAULT,
+ CHRE_SENSOR_LATENCY_DEFAULT);
+}
+
+/**
+ * Convenience function that wraps chreSensorConfigure but enables batching to
+ * be controlled by specifying the desired maximum batch interval rather
+ * than maximum sample latency. Users may find the batch interval to be a more
+ * intuitive method of expressing the desired batching behavior.
+ *
+ * Batch interval is different from latency as the batch interval time is
+ * counted starting when the prior event containing a batch of sensor samples is
+ * delivered, while latency starts counting when the first sample is deferred to
+ * start collecting a batch. In other words, latency ignores the time between
+ * the last sample in a batch to the first sample of the next batch, while it's
+ * included in the batch interval, as illustrated below.
+ *
+ * Time 0 1 2 3 4 5 6 7 8
+ * Batch A B C
+ * Sample a1 a2 a3 b1 b2 b3 c1 c2 c3
+ * Latency [ ] [ ] [ ]
+ * BatchInt | | |
+ *
+ * In the diagram, the effective sample interval is 1 time unit, latency is 2
+ * time units, and batch interval is 3 time units.
+ *
+ * @param sensorHandle See chreSensorConfigure#sensorHandle
+ * @param mode See chreSensorConfigure#mode
+ * @param sampleInterval See chreSensorConfigure#interval, but note that
+ * CHRE_SENSOR_INTERVAL_DEFAULT is not a supported input to this method.
+ * @param batchInterval The desired maximum interval, in nanoseconds, between
+ * CHRE enqueuing each batch of sensor samples.
+ * @return Same as chreSensorConfigure
+ *
+ * @see chreSensorConfigure
+ *
+ * @since v1.1
+ */
+static inline bool chreSensorConfigureWithBatchInterval(
+ uint32_t sensorHandle, enum chreSensorConfigureMode mode,
+ uint64_t sampleInterval, uint64_t batchInterval) {
+ bool result = false;
+
+ if (sampleInterval != CHRE_SENSOR_INTERVAL_DEFAULT) {
+ uint64_t latency;
+ if (batchInterval == CHRE_SENSOR_BATCH_INTERVAL_DEFAULT) {
+ latency = CHRE_SENSOR_LATENCY_DEFAULT;
+ } else if (batchInterval > sampleInterval) {
+ latency = batchInterval - sampleInterval;
+ } else {
+ latency = CHRE_SENSOR_LATENCY_ASAP;
+ }
+ result = chreSensorConfigure(sensorHandle, mode, sampleInterval,
+ latency);
+ }
+
+ return result;
+}
+
+/**
+ * Configures the reception of bias events for a specific sensor.
+ *
+ * If bias event delivery is supported for a sensor, the sensor's chreSensorInfo
+ * has reportsBiasEvents set to 1. If supported, it must be supported for both
+ * calibrated and uncalibrated versions of the sensor. If supported, CHRE must
+ * provide bias events to the nanoapp by default when chreSensorConfigure is
+ * called to enable the calibrated version of the sensor (for backwards
+ * compatibility reasons, as this is the defined behavior for CHRE API v1.0).
+ * When configuring uncalibrated sensors, nanoapps must explicitly configure an
+ * enable request through this method to receive bias events. If bias event
+ * delivery is not supported for the sensor, this method will return false and
+ * no bias events will be generated.
+ *
+ * To enable bias event delivery (enable=true), the nanoapp must be registered
+ * to the sensor through chreSensorConfigure, and bias events will only be
+ * generated when the sensor is powered on. To disable the bias event delivery,
+ * this method can be invoked with enable=false.
+ *
+ * If an enable configuration is successful, the calling nanoapp will receive
+ * bias info events, e.g. CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO, when the
+ * bias status changes (or first becomes available). Calibrated data
+ * (e.g. CHRE_SENSOR_TYPE_ACCELEROMETER) is generated by subracting bias from
+ * uncalibrated data (e.g. CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER).
+ * Calibrated sensor events are generated by applying the most recent bias
+ * available (i.e. timestamp of calibrated data are greater than or equal to the
+ * timestamp of the bias data that has been applied to it). The configuration of
+ * bias event delivery persists until the sensor is unregistered by the nanoapp
+ * through chreSensorConfigure or modified through this method.
+ *
+ * To get an initial bias before new bias events, the nanoapp should get the
+ * bias synchronously after this method is invoked, e.g.:
+ *
+ * if (chreSensorConfigure(handle, ...)) {
+ * chreSensorConfigureBiasEvents(handle, true);
+ * chreSensorGetThreeAxisBias(handle, &bias);
+ * }
+ *
+ * Note that chreSensorGetThreeAxisBias() should be called after
+ * chreSensorConfigureBiasEvents() to ensure that no bias events are lost.
+ *
+ * If called while running on a CHRE API version below v1.3, this function
+ * returns false and has no effect. The default behavior regarding bias events
+ * is unchanged, meaning that the implementation may still send bias events
+ * when a calibrated sensor is registered (if supported), and will not send bias
+ * events when an uncalibrated sensor is registered.
+ *
+ * @param sensorHandle The handle to the sensor, as obtained from
+ * chreSensorFindDefault().
+ * @param enable true to receive bias events, false otherwise
+ *
+ * @return true if the configuration succeeded, false otherwise
+ *
+ * @since v1.3
+ */
+bool chreSensorConfigureBiasEvents(uint32_t sensorHandle, bool enable);
+
+/**
+ * Synchronously provides the most recent bias info available for a sensor. The
+ * bias will only be provided for a sensor that supports bias event delivery
+ * using the chreSensorThreeAxisData type. If the bias is not yet available
+ * (but is supported), this method will store data with a bias of 0 and the
+ * accuracy field in chreSensorDataHeader set to CHRE_SENSOR_ACCURACY_UNKNOWN.
+ *
+ * If called while running on a CHRE API version below v1.3, this function
+ * returns false.
+ *
+ * @param sensorHandle The handle to the sensor, as obtained from
+ * chreSensorFindDefault().
+ * @param bias A pointer to where the bias will be stored.
+ *
+ * @return true if the bias was successfully stored, false if sensorHandle was
+ * invalid or the sensor does not support three axis bias delivery
+ *
+ * @since v1.3
+ *
+ * @see chreSensorConfigureBiasEvents
+ */
+bool chreSensorGetThreeAxisBias(uint32_t sensorHandle,
+ struct chreSensorThreeAxisData *bias);
+
+/**
+ * Makes a request to flush all samples stored for batching. The nanoapp must be
+ * registered to the sensor through chreSensorConfigure, and the sensor must be
+ * powered on. If the request is accepted, all batched samples of the sensor
+ * are sent to nanoapps registered to the sensor. During a flush, it is treated
+ * as though the latency as given in chreSensorConfigure has expired. When all
+ * batched samples have been flushed (or the flush fails), the nanoapp will
+ * receive a unicast CHRE_EVENT_SENSOR_FLUSH_COMPLETE event. The time to deliver
+ * this event must not exceed CHRE_SENSOR_FLUSH_COMPLETE_TIMEOUT_NS after this
+ * method is invoked. If there are no samples in the batch buffer (either in
+ * hardware FIFO or software), then this method will return true and a
+ * CHRE_EVENT_SENSOR_FLUSH_COMPLETE event is delivered immediately.
+ *
+ * If a flush request is invalid (e.g. the sensor refers to a one-shot sensor,
+ * or the sensor was not enabled), and this API will return false and no
+ * CHRE_EVENT_SENSOR_FLUSH_COMPLETE event will be delivered.
+ *
+ * If multiple flush requests are made for a sensor prior to flush completion,
+ * then the requesting nanoapp will receive all batched samples existing at the
+ * time of the latest flush request. In this case, the number of
+ * CHRE_EVENT_SENSOR_FLUSH_COMPLETE events received must equal the number of
+ * flush requests made.
+ *
+ * If a sensor request is disabled after a flush request is made through this
+ * method but before the flush operation is completed, the nanoapp will receive
+ * a CHRE_EVENT_SENSOR_FLUSH_COMPLETE with the error code
+ * CHRE_ERROR_FUNCTION_DISABLED for any pending flush requests.
+ *
+ * Starting with CHRE API v1.3, implementations must support this capability
+ * across all exposed sensor types.
+ *
+ * @param sensorHandle The handle to the sensor, as obtained from
+ * chreSensorFindDefault().
+ * @param cookie An opaque value that will be included in the
+ * chreSensorFlushCompleteEvent sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.3
+ */
+bool chreSensorFlushAsync(uint32_t sensorHandle, const void *cookie);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_SENSOR_H_ */
diff --git a/chre_api/legacy/v1_10/chre/sensor_types.h b/chre_api/legacy/v1_10/chre/sensor_types.h
new file mode 100644
index 0000000..6b46a22
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/sensor_types.h
@@ -0,0 +1,483 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_SENSOR_TYPES_H_
+#define _CHRE_SENSOR_TYPES_H_
+
+/**
+ * @file
+ * Standalone definition of sensor types, and the data structures of the sample
+ * events they emit.
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file
+ * The CHRE_SENSOR_TYPE_* defines are the sensor types supported.
+ *
+ * Unless otherwise noted, each of these sensor types is based off of a
+ * corresponding sensor type in the Android API's sensors.h interface.
+ * For a given CHRE_SENSOR_TYPE_FOO, it corresponds to the SENSOR_TYPE_FOO in
+ * hardware/libhardware/include/hardware/sensors.h of the Android code base.
+ *
+ * Unless otherwise noted below, a CHRE_SENSOR_TYPE_FOO should be assumed
+ * to work the same as the Android SENSOR_TYPE_FOO, as documented in the
+ * sensors.h documentation and as detailed within the Android Compatibility
+ * Definition Document.
+ *
+ * Note that every sensor will generate CHRE_EVENT_SENSOR_SAMPLING_CHANGE
+ * events, so it is not listed with each individual sensor.
+ */
+
+/**
+ * Start value for all of the vendor-defined private sensors.
+ *
+ * @since v1.2
+ */
+#define CHRE_SENSOR_TYPE_VENDOR_START UINT8_C(0xC0)
+
+/**
+ * Accelerometer.
+ *
+ * Generates: CHRE_EVENT_SENSOR_ACCELEROMETER_DATA and
+ * optionally CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO
+ *
+ * Note that the ACCELEROMETER_DATA is always the fully calibrated data,
+ * including factory calibration and runtime calibration if available.
+ *
+ * @see chreConfigureSensorBiasEvents
+ */
+#define CHRE_SENSOR_TYPE_ACCELEROMETER UINT8_C(0x01)
+
+/**
+ * Instantaneous motion detection.
+ *
+ * Generates: CHRE_EVENT_SENSOR_INSTANT_MOTION_DETECT_DATA
+ *
+ * This is a one-shot sensor.
+ *
+ * This does not have a direct analogy within sensors.h. This is similar
+ * to SENSOR_TYPE_MOTION_DETECT, but this triggers instantly upon any
+ * motion, instead of waiting for a period of continuous motion.
+ */
+#define CHRE_SENSOR_TYPE_INSTANT_MOTION_DETECT UINT8_C(0x02)
+
+/**
+ * Stationary detection.
+ *
+ * Generates: CHRE_EVENT_SENSOR_STATIONARY_DETECT_DATA
+ *
+ * This is a one-shot sensor.
+ */
+#define CHRE_SENSOR_TYPE_STATIONARY_DETECT UINT8_C(0x03)
+
+/**
+ * Gyroscope.
+ *
+ * Generates: CHRE_EVENT_SENSOR_GYROSCOPE_DATA and
+ * optionally CHRE_EVENT_SENSOR_GYROSCOPE_BIAS_INFO
+ *
+ * Note that the GYROSCOPE_DATA is always the fully calibrated data, including
+ * factory calibration and runtime calibration if available.
+ *
+ * @see chreConfigureSensorBiasEvents
+ */
+#define CHRE_SENSOR_TYPE_GYROSCOPE UINT8_C(0x06)
+
+/**
+ * Uncalibrated gyroscope.
+ *
+ * Generates: CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA
+ *
+ * Note that the UNCALIBRATED_GYROSCOPE_DATA must be factory calibrated data,
+ * but not runtime calibrated.
+ */
+#define CHRE_SENSOR_TYPE_UNCALIBRATED_GYROSCOPE UINT8_C(0x07)
+
+/**
+ * Magnetometer.
+ *
+ * Generates: CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_DATA and
+ * optionally CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_BIAS_INFO
+ *
+ * Note that the GEOMAGNETIC_FIELD_DATA is always the fully calibrated data,
+ * including factory calibration and runtime calibration if available.
+ *
+ * @see chreConfigureSensorBiasEvents
+ */
+#define CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD UINT8_C(0x08)
+
+/**
+ * Uncalibrated magnetometer.
+ *
+ * Generates: CHRE_EVENT_SENSOR_UNCALIBRATED_GEOMAGNETIC_FIELD_DATA
+ *
+ * Note that the UNCALIBRATED_GEOMAGNETIC_FIELD_DATA must be factory calibrated
+ * data, but not runtime calibrated.
+ */
+#define CHRE_SENSOR_TYPE_UNCALIBRATED_GEOMAGNETIC_FIELD UINT8_C(0x09)
+
+/**
+ * Barometric pressure sensor.
+ *
+ * Generates: CHRE_EVENT_SENSOR_PRESSURE_DATA
+ */
+#define CHRE_SENSOR_TYPE_PRESSURE UINT8_C(0x0A)
+
+/**
+ * Ambient light sensor.
+ *
+ * Generates: CHRE_EVENT_SENSOR_LIGHT_DATA
+ *
+ * This is an on-change sensor.
+ */
+#define CHRE_SENSOR_TYPE_LIGHT UINT8_C(0x0C)
+
+/**
+ * Proximity detection.
+ *
+ * Generates: CHRE_EVENT_SENSOR_PROXIMITY_DATA
+ *
+ * This is an on-change sensor.
+ */
+#define CHRE_SENSOR_TYPE_PROXIMITY UINT8_C(0x0D)
+
+/**
+ * Step detection.
+ *
+ * Generates: CHRE_EVENT_SENSOR_STEP_DETECT_DATA
+ *
+ * @since v1.3
+ */
+#define CHRE_SENSOR_TYPE_STEP_DETECT UINT8_C(0x17)
+
+/**
+ * Step counter.
+ *
+ * Generates: CHRE_EVENT_SENSOR_STEP_COUNTER_DATA
+ *
+ * This is an on-change sensor. Note that the data returned by this sensor must
+ * match the value that can be obtained via the Android sensors framework at the
+ * same point in time. This means, if CHRE reboots from the rest of the system,
+ * the counter must not reset to 0.
+ *
+ * @since v1.5
+ */
+#define CHRE_SENSOR_TYPE_STEP_COUNTER UINT8_C(0x18)
+
+/**
+ * Significant motion detection.
+ *
+ * Generates: CHRE_EVENT_SENSOR_SIGNIFICANT_MOTION_DATA
+ *
+ * This is a one-shot sensor.
+ *
+ * @since v1.10
+ */
+#define CHRE_SENSOR_TYPE_SIGNIFICANT_MOTION UINT8_C(0x1C)
+
+/**
+ * Hinge angle sensor.
+ *
+ * Generates: CHRE_EVENT_SENSOR_HINGE_ANGLE_DATA
+ *
+ * This is an on-change sensor.
+ *
+ * A sensor of this type measures the angle, in degrees, between two
+ * integral parts of the device. Movement of a hinge measured by this sensor
+ * type is expected to alter the ways in which the user may interact with
+ * the device, for example by unfolding or revealing a display.
+ *
+ * @since v1.5
+ */
+#define CHRE_SENSOR_TYPE_HINGE_ANGLE UINT8_C(0x24)
+
+/**
+ * Uncalibrated accelerometer.
+ *
+ * Generates: CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_DATA
+ *
+ * Note that the UNCALIBRATED_ACCELEROMETER_DATA must be factory calibrated
+ * data, but not runtime calibrated.
+ */
+#define CHRE_SENSOR_TYPE_UNCALIBRATED_ACCELEROMETER UINT8_C(0x37)
+
+/**
+ * Accelerometer temperature.
+ *
+ * Generates: CHRE_EVENT_SENSOR_ACCELEROMETER_TEMPERATURE_DATA
+ */
+#define CHRE_SENSOR_TYPE_ACCELEROMETER_TEMPERATURE UINT8_C(0x38)
+
+/**
+ * Gyroscope temperature.
+ *
+ * Generates: CHRE_EVENT_SENSOR_GYROSCOPE_TEMPERATURE_DATA
+ */
+#define CHRE_SENSOR_TYPE_GYROSCOPE_TEMPERATURE UINT8_C(0x39)
+
+/**
+ * Magnetometer temperature.
+ *
+ * Generates: CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_TEMPERATURE_DATA
+ */
+#define CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE UINT8_C(0x3A)
+
+#if CHRE_SENSOR_TYPE_GEOMAGNETIC_FIELD_TEMPERATURE >= CHRE_SENSOR_TYPE_VENDOR_START
+#error Too many sensor types
+#endif
+
+/**
+ * Values that can be stored in the accuracy field of chreSensorDataHeader.
+ * If CHRE_SENSOR_ACCURACY_UNKNOWN is returned, then the driver did not provide
+ * accuracy information with the data. Values in the range
+ * [CHRE_SENSOR_ACCURACY_VENDOR_START, CHRE_SENSOR_ACCURACY_VENDOR_END] are
+ * reserved for vendor-specific values for vendor sensor types, and are not used
+ * by CHRE for standard sensor types.
+ *
+ * Otherwise, the values have the same meaning as defined in the Android
+ * Sensors definition:
+ * https://developer.android.com/reference/android/hardware/SensorManager
+ *
+ * @since v1.3
+ *
+ * @defgroup CHRE_SENSOR_ACCURACY
+ * @{
+ */
+
+#define CHRE_SENSOR_ACCURACY_UNKNOWN UINT8_C(0x00)
+#define CHRE_SENSOR_ACCURACY_UNRELIABLE UINT8_C(0x01)
+#define CHRE_SENSOR_ACCURACY_LOW UINT8_C(0x02)
+#define CHRE_SENSOR_ACCURACY_MEDIUM UINT8_C(0x03)
+#define CHRE_SENSOR_ACCURACY_HIGH UINT8_C(0x04)
+#define CHRE_SENSOR_ACCURACY_VENDOR_START UINT8_C(0xC0)
+#define CHRE_SENSOR_ACCURACY_VENDOR_END UINT8_MAX
+
+/** @} */
+
+/**
+ * Header used in every structure containing batchable data from a sensor.
+ *
+ * The typical structure for sensor data looks like:
+ *
+ * struct chreSensorTypeData {
+ * struct chreSensorDataHeader header;
+ * struct chreSensorTypeSampleData {
+ * uint32_t timestampDelta;
+ * union {
+ * <type> value;
+ * <type> interpretation0;
+ * <type> interpretation1;
+ * };
+ * } readings[1];
+ * };
+ *
+ * Despite 'readings' being declared as an array of 1 element,
+ * an instance of the struct will actually have 'readings' as
+ * an array of header.readingCount elements (which may be 1).
+ * The 'timestampDelta' is in relation to the previous 'readings' (or
+ * the baseTimestamp for readings[0]. So,
+ * Timestamp for readings[0] == header.baseTimestamp +
+ * readings[0].timestampDelta.
+ * Timestamp for readings[1] == timestamp for readings[0] +
+ * readings[1].timestampDelta.
+ * And thus, in order to determine the timestamp for readings[N], it's
+ * necessary to process through all of the N-1 readings. The advantage,
+ * though, is that our entire readings can span an arbitrary length of time,
+ * just as long as any two consecutive readings differ by no more than
+ * 4.295 seconds (timestampDelta, like all time in the CHRE, is in
+ * nanoseconds).
+ *
+ * If a sensor has batched readings where two consecutive readings differ by
+ * more than 4.295 seconds, the CHRE will split them across multiple
+ * instances of the struct, and send multiple events.
+ *
+ * The value from the sensor is typically expressed in a union,
+ * allowing a generic access to the data ('value'), along with
+ * differently named access giving a more natural interpretation
+ * of the data for the specific sensor types which use this
+ * structure. This allows, for example, barometer code to
+ * reference readings[N].pressure, and an ambient light sensor
+ * to reference readings[N].light, while both use the same
+ * structure.
+ */
+struct chreSensorDataHeader {
+ /**
+ * The base timestamp, in nanoseconds; must be in the same time base as
+ * chreGetTime().
+ */
+ uint64_t baseTimestamp;
+
+ /**
+ * The handle of the sensor producing this event.
+ */
+ uint32_t sensorHandle;
+
+ /**
+ * The number elements in the 'readings' array.
+ *
+ * This must be at least 1.
+ */
+ uint16_t readingCount;
+
+ /**
+ * The accuracy of the sensor data.
+ *
+ * @ref CHRE_SENSOR_ACCURACY
+ *
+ * @since v1.3
+ */
+ uint8_t accuracy;
+
+ /**
+ * Reserved bytes.
+ *
+ * This must be 0.
+ */
+ uint8_t reserved;
+};
+
+/**
+ * Data for a sensor which reports on three axes.
+ *
+ * This is used by CHRE_EVENT_SENSOR_ACCELEROMETER_DATA,
+ * CHRE_EVENT_SENSOR_ACCELEROMETER_BIAS_INFO,
+ * CHRE_EVENT_SENSOR_UNCALIBRATED_ACCELEROMETER_DATA,
+ * CHRE_EVENT_SENSOR_GYROSCOPE_DATA,
+ * CHRE_EVENT_SENSOR_GYROSCOPE_BIAS_INFO,
+ * CHRE_EVENT_SENSOR_UNCALIBRATED_GYROSCOPE_DATA,
+ * CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_DATA,
+ * CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_BIAS_INFO, and
+ * CHRE_EVENT_SENSOR_UNCALIBRATED_GEOMAGNETIC_FIELD_DATA.
+ */
+struct chreSensorThreeAxisData {
+ /**
+ * @see chreSensorDataHeader
+ */
+ struct chreSensorDataHeader header;
+ struct chreSensorThreeAxisSampleData {
+ /**
+ * @see chreSensorDataHeader
+ */
+ uint32_t timestampDelta;
+ union {
+ float values[3];
+ float v[3];
+ struct {
+ float x;
+ float y;
+ float z;
+ };
+ float bias[3];
+ struct {
+ float x_bias;
+ float y_bias;
+ float z_bias;
+ };
+ };
+ } readings[1];
+};
+
+/**
+ * Data from a sensor where we only care about a event occurring.
+ *
+ * This is a bit unusual in that our readings have no data in addition
+ * to the timestamp. But since we only care about the occurrence, we
+ * don't need to know anything else.
+ *
+ * Used by: CHRE_EVENT_SENSOR_INSTANT_MOTION_DETECT_DATA,
+ * CHRE_EVENT_SENSOR_STATIONARY_DETECT_DATA,
+ * CHRE_EVENT_SENSOR_STEP_DETECT_DATA, and
+ * CHRE_EVENT_SENSOR_SIGNIFICANT_MOTION_DATA.
+ */
+struct chreSensorOccurrenceData {
+ struct chreSensorDataHeader header;
+ struct chreSensorOccurrenceSampleData {
+ uint32_t timestampDelta;
+ // This space intentionally left blank.
+ // Only the timestamp is meaningful here, there
+ // is no additional data.
+ } readings[1];
+};
+
+/**
+ * This is used by CHRE_EVENT_SENSOR_LIGHT_DATA,
+ * CHRE_EVENT_SENSOR_PRESSURE_DATA,
+ * CHRE_EVENT_SENSOR_ACCELEROMETER_TEMPERATURE_DATA,
+ * CHRE_EVENT_SENSOR_GYROSCOPE_TEMPERATURE_DATA,
+ * CHRE_EVENT_SENSOR_GEOMAGNETIC_FIELD_TEMPERATURE_DATA, and
+ * CHRE_EVENT_SENSOR_HINGE_ANGLE_DATA.
+ */
+struct chreSensorFloatData {
+ struct chreSensorDataHeader header;
+ struct chreSensorFloatSampleData {
+ uint32_t timestampDelta;
+ union {
+ float value;
+ float light; //!< Unit: lux
+ float pressure; //!< Unit: hectopascals (hPa)
+ float temperature; //!< Unit: degrees Celsius
+ float angle; //!< Unit: angular degrees
+ };
+ } readings[1];
+};
+
+/**
+ * CHRE_EVENT_SENSOR_PROXIMITY_DATA.
+ */
+struct chreSensorByteData {
+ struct chreSensorDataHeader header;
+ struct chreSensorByteSampleData {
+ uint32_t timestampDelta;
+ union {
+ uint8_t value;
+ struct {
+ uint8_t isNear : 1;
+ //! @deprecated As of v1.2, this field is deprecated and must
+ //! always be set to 0
+ uint8_t invalid : 1;
+ uint8_t padding0 : 6;
+ };
+ };
+ } readings[1];
+};
+
+/**
+ * Data for a sensor which reports a single uint64 value.
+ *
+ * This is used by CHRE_EVENT_SENSOR_STEP_COUNTER_DATA.
+ */
+struct chreSensorUint64Data {
+ struct chreSensorDataHeader header;
+ struct chreSensorUint64SampleData {
+ uint32_t timestampDelta;
+ uint64_t value;
+ } readings[1];
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_SENSOR_TYPES_H_ */
diff --git a/chre_api/legacy/v1_10/chre/toolchain.h b/chre_api/legacy/v1_10/chre/toolchain.h
new file mode 100644
index 0000000..7c93bb1
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/toolchain.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef CHRE_TOOLCHAIN_H_
+#define CHRE_TOOLCHAIN_H_
+
+/**
+ * @file
+ * Compiler/build toolchain-specific macros used by the CHRE API
+ */
+
+#if defined(__GNUC__) || defined(__clang__)
+// For GCC and clang
+
+#define CHRE_DEPRECATED(message) \
+ __attribute__((deprecated(message)))
+
+// Indicates that the function does not return (i.e. abort).
+#define CHRE_NO_RETURN __attribute__((noreturn))
+
+// Enable printf-style compiler warnings for mismatched format string and args
+#define CHRE_PRINTF_ATTR(formatPos, argStart) \
+ __attribute__((format(printf, formatPos, argStart)))
+
+#define CHRE_BUILD_ERROR(message) CHRE_DO_PRAGMA(GCC error message)
+#define CHRE_DO_PRAGMA(message) _Pragma(#message)
+
+// Marks a function as malloc-like, for optimizations with the return pointer
+#define CHRE_MALLOC_ATTR __attribute__((__malloc__))
+
+#elif defined(__ICCARM__) || defined(__CC_ARM)
+// For IAR ARM and Keil MDK-ARM compilers
+
+#define CHRE_PRINTF_ATTR(formatPos, argStart)
+
+#define CHRE_DEPRECATED(message)
+
+#define CHRE_NO_RETURN
+
+#define CHRE_MALLOC_ATTR
+
+#elif defined(_MSC_VER)
+// For Microsoft Visual Studio
+
+#define CHRE_PRINTF_ATTR(formatPos, argStart)
+
+#define CHRE_DEPRECATED(message)
+
+#define CHRE_NO_RETURN
+
+#define CHRE_MALLOC_ATTR
+
+#else // if !defined(__GNUC__) && !defined(__clang__)
+
+#error Need to add support for new compiler
+
+#endif
+
+// For platforms that don't support error pragmas, utilize the best method of
+// showing an error depending on the platform support.
+#ifndef CHRE_BUILD_ERROR
+#ifdef __cplusplus // C++17 or greater assumed
+#define CHRE_BUILD_ERROR(message) static_assert(0, message)
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define CHRE_BUILD_ERROR(message) _Static_assert(0, message)
+#else
+#define CHRE_BUILD_ERROR(message) char buildError[-1] = message
+#endif
+#endif
+
+#endif // CHRE_TOOLCHAIN_H_
diff --git a/chre_api/legacy/v1_10/chre/user_settings.h b/chre_api/legacy/v1_10/chre/user_settings.h
new file mode 100644
index 0000000..a13290d
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/user_settings.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_USER_SETTINGS_H_
+#define _CHRE_USER_SETTINGS_H_
+
+/**
+ * @file
+ * The API for requesting notifications on changes in the settings of the
+ * active user. If the device is set up with one or more secondary users
+ * (see https://source.android.com/devices/tech/admin/multi-user), the user
+ * settings in CHRE reflect that of the currently active user.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <chre/event.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The user settings that nanoapps can request notifications for on a status
+ * change.
+ *
+ * NOTE: The WIFI available setting indicates the overall availability
+ * of WIFI related functionality. For example, if wifi is disabled for
+ * connectivity but enabled for location, the WIFI available setting is
+ * enabled.
+ *
+ * NOTE: The BLE available setting is the logical OR of the main Bluetooth
+ * setting and the Bluetooth scanning setting found under Location settings.
+ * Note that this indicates whether the user is allowing Bluetooth to be used,
+ * however the system may still fully power down the BLE chip in some scenarios
+ * if no request for it exists on the Android host side. See the
+ * chreBleStartScanAsync() API documentation for more information.
+ *
+ * @defgroup CHRE_USER_SETTINGS
+ * @{
+ */
+#define CHRE_USER_SETTING_LOCATION UINT8_C(0)
+#define CHRE_USER_SETTING_WIFI_AVAILABLE UINT8_C(1)
+#define CHRE_USER_SETTING_AIRPLANE_MODE UINT8_C(2)
+#define CHRE_USER_SETTING_MICROPHONE UINT8_C(3)
+#define CHRE_USER_SETTING_BLE_AVAILABLE UINT8_C(4)
+
+/** @} */
+
+/**
+ * Produce an event ID in the block of IDs reserved for settings notifications.
+ *
+ * @param offset Index into the event ID block, valid in the range [0,15]
+ */
+#define CHRE_SETTING_EVENT_ID(offset) (CHRE_EVENT_SETTING_CHANGED_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreUserSettingChangedEvent
+ *
+ * Notify nanoapps of a change in the associated setting. Nanoapps must first
+ * register (via chreUserSettingConfigureEvents) for events before they are
+ * sent out.
+ */
+#define CHRE_EVENT_SETTING_CHANGED_LOCATION CHRE_SETTING_EVENT_ID(0)
+#define CHRE_EVENT_SETTING_CHANGED_WIFI_AVAILABLE CHRE_SETTING_EVENT_ID(1)
+#define CHRE_EVENT_SETTING_CHANGED_AIRPLANE_MODE CHRE_SETTING_EVENT_ID(2)
+#define CHRE_EVENT_SETTING_CHANGED_MICROPHONE CHRE_SETTING_EVENT_ID(3)
+#define CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE CHRE_SETTING_EVENT_ID(4)
+
+#if CHRE_EVENT_SETTING_CHANGED_BLE_AVAILABLE > CHRE_EVENT_SETTING_CHANGED_LAST_EVENT
+#error Too many setting changed events.
+#endif
+
+/**
+ * Indicates the current state of a setting.
+ * The setting state is 'unknown' only in the following scenarios:
+ * - CHRE hasn't received the initial state yet on a restart.
+ * - The nanoapp is running on CHRE v1.4 or older
+ * - Nanoapp provided in invalid setting ID to chreUserSettingGetStatus.
+ */
+enum chreUserSettingState {
+ CHRE_USER_SETTING_STATE_UNKNOWN = -1,
+ CHRE_USER_SETTING_STATE_DISABLED = 0,
+ CHRE_USER_SETTING_STATE_ENABLED = 1
+};
+
+/**
+ * The nanoappHandleEvent argument for CHRE settings changed notifications.
+ */
+struct chreUserSettingChangedEvent {
+ //! Indicates the setting whose state has changed.
+ uint8_t setting;
+
+ //! A value that corresponds to a member in enum chreUserSettingState,
+ // indicating the latest value of the setting.
+ int8_t settingState;
+};
+
+/**
+ * Get the current state of a given setting.
+ *
+ * @param setting The setting to get the current status of.
+ *
+ * @return The current state of the requested setting. The state is returned
+ * as an int8_t to be consistent with the associated event data, but is
+ * guaranteed to be a valid enum chreUserSettingState member.
+ *
+ * @since v1.5
+ */
+int8_t chreUserSettingGetState(uint8_t setting);
+
+/**
+ * Register or deregister for a notification on a status change for a given
+ * setting. Note that registration does not produce an event with the initial
+ * (or current) state, though nanoapps can use chreUserSettingGetState() for
+ * this purpose.
+ *
+ * @param setting The setting on whose change a notification is desired.
+ * @param enable The nanoapp is registered to receive notifications on a
+ * change in the user settings if this parameter is true, otherwise the
+ * nanoapp receives no further notifications for this setting.
+ *
+ * @since v1.5
+ */
+void chreUserSettingConfigureEvents(uint8_t setting, bool enable);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_USER_SETTINGS_H_ */
diff --git a/chre_api/legacy/v1_10/chre/version.h b/chre_api/legacy/v1_10/chre/version.h
new file mode 100644
index 0000000..8f4e3d6
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/version.h
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_VERSION_H_
+#define _CHRE_VERSION_H_
+
+/**
+ * @file
+ * Definitions and methods for the versioning of the Context Hub Runtime
+ * Environment.
+ *
+ * The CHRE API versioning pertains to all header files in the CHRE API.
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Value for version 0.1 of the Context Hub Runtime Environment API interface.
+ *
+ * This is a legacy version of the CHRE API. Version 1.0 is considered the first
+ * official CHRE API version.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_0_1 UINT32_C(0x00010000)
+
+/**
+ * Value for version 1.0 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android Nougat release.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_0 UINT32_C(0x01000000)
+
+/**
+ * Value for version 1.1 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android O release. It adds
+ * initial support for new GNSS, WiFi, and WWAN modules.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_1 UINT32_C(0x01010000)
+
+/**
+ * Value for version 1.2 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android P release. It adds
+ * initial support for the new audio module.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_2 UINT32_C(0x01020000)
+
+/**
+ * Value for version 1.3 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android Q release. It adds
+ * support for GNSS location altitude/speed/bearing accuracy. It also adds step
+ * detect as a standard CHRE sensor and supports bias event delivery and sensor
+ * data flushing.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_3 UINT32_C(0x01030000)
+
+/**
+ * Value for version 1.4 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android R release. It adds
+ * support for collecting debug dump information from nanoapps, receiving L5
+ * GNSS measurements, determining if a sensor supports passive requests,
+ * receiving 5G cell info, and deprecates chreSendMessageToHost.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_4 UINT32_C(0x01040000)
+
+/**
+ * Value for version 1.5 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API shipped with the Android S release. It adds
+ * support for multiple sensors of the same type, permissions for sensitive CHRE
+ * APIs / data usage, ability to receive user settings updates, step counter and
+ * hinge angle sensors, improved WiFi scan preferences to support power
+ * optimization, new WiFi security types, increased the lower bound for the
+ * maximum CHRE to host message size, and increased GNSS measurements in
+ * chreGnssDataEvent.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_5 UINT32_C(0x01050000)
+
+/**
+ * Value for version 1.6 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with the Android T release. It adds
+ * support for BLE scanning, subscribing to the WiFi NAN discovery engine,
+ * subscribing to host endpoint notifications, requesting metadata for a host
+ * endpoint ID, nanoapps publishing RPC services they support, and limits the
+ * nanoapp instance ID size to INT16_MAX.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_6 UINT32_C(0x01060000)
+
+/**
+ * Value for version 1.7 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with a post-launch update to the
+ * Android T release. It adds the BLE flush API.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_7 UINT32_C(0x01070000)
+
+/**
+ * Value for version 1.8 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with the Android U release. It adds
+ * support for filtering by manufacturer data in BLE scans, reading the RSSI
+ * value of a BLE connection, allowing the nanoapp to check BLE scan status,
+ * allowing the nanoapp to specify which RPC services it supports, and
+ * delivering batch complete events for batched BLE scans.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_8 UINT32_C(0x01080000)
+
+/**
+ * Value for version 1.9 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with a post-launch update to the
+ * Android U release. It adds the BLE Broadcaster Address filter.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_9 UINT32_C(0x01090000)
+
+/**
+ * Value for version 1.10 of the Context Hub Runtime Environment API interface.
+ *
+ * This version of the CHRE API is shipped with Android V. It adds support for
+ * reliable messaging.
+ *
+ * @note This version of the CHRE API has not been finalized yet, and is
+ * currently considered a preview that is subject to change.
+ *
+ * @see CHRE_API_VERSION
+ */
+#define CHRE_API_VERSION_1_10 UINT32_C(0x010a0000)
+
+/**
+ * Major and Minor Version of this Context Hub Runtime Environment API.
+ *
+ * The major version changes when there is an incompatible API change.
+ *
+ * The minor version changes when there is an addition in functionality
+ * in a backwards-compatible manner.
+ *
+ * We define the version number as an unsigned 32-bit value. The most
+ * significant byte is the Major Version. The second-most significant byte
+ * is the Minor Version. The two least significant bytes are the Patch
+ * Version. The Patch Version is not defined by this header API, but
+ * is provided by a specific CHRE implementation (see chreGetVersion()).
+ *
+ * Note that version numbers can always be numerically compared with
+ * expected results, so 1.0.0 < 1.0.4 < 1.1.0 < 2.0.300 < 3.5.0.
+ */
+#define CHRE_API_VERSION CHRE_API_VERSION_1_10
+
+/**
+ * Utility macro to extract only the API major version of a composite CHRE
+ * version.
+ *
+ * @param version A uint32_t version, e.g. the value returned by
+ * chreGetApiVersion()
+ *
+ * @return The API major version in the least significant byte, e.g. 0x01
+ */
+#define CHRE_EXTRACT_MAJOR_VERSION(version) \
+ (uint32_t)(((version) & UINT32_C(0xFF000000)) >> 24)
+
+/**
+ * Utility macro to extract only the API minor version of a composite CHRE
+ * version.
+ *
+ * @param version A uint32_t version, e.g. the CHRE_API_VERSION constant
+ *
+ * @return The API minor version in the least significant byte, e.g. 0x01
+ */
+#define CHRE_EXTRACT_MINOR_VERSION(version) \
+ (uint32_t)(((version) & UINT32_C(0x00FF0000)) >> 16)
+
+/**
+ * Utility macro to extract only the API minor version of a composite CHRE
+ * version.
+ *
+ * @param version A complete uint32_t version, e.g. the value returned by
+ * chreGetVersion()
+ *
+ * @return The implementation patch version in the least significant two bytes,
+ * e.g. 0x0123, with all other bytes set to 0
+ */
+#define CHRE_EXTRACT_PATCH_VERSION(version) (uint32_t)((version) & UINT32_C(0xFFFF))
+
+/**
+ * Get the API version the CHRE implementation was compiled against.
+ *
+ * This is not necessarily the CHRE_API_VERSION in the header the nanoapp was
+ * built against, and indeed may not have even appeared in the context_hub_os.h
+ * header which this nanoapp was built against.
+ *
+ * By definition, this will have the two least significant bytes set to 0,
+ * and only contain the major and minor version number.
+ *
+ * @return The API version.
+ */
+uint32_t chreGetApiVersion(void);
+
+/**
+ * Get the version of this CHRE implementation.
+ *
+ * By definition, ((chreGetApiVersion() & UINT32_C(0xFFFF0000)) ==
+ * (chreGetVersion() & UINT32_C(0xFFFF0000))).
+ *
+ * The Patch Version, in the lower two bytes, only have meaning in context
+ * of this specific platform ID. It is increased by the platform every time
+ * a backwards-compatible bug fix is released.
+ *
+ * @return The version.
+ *
+ * @see chreGetPlatformId()
+ */
+uint32_t chreGetVersion(void);
+
+/**
+ * Get the Platform ID of this CHRE.
+ *
+ * The most significant five bytes are the vendor ID as set out by the
+ * NANOAPP_VENDOR convention in the original context hub HAL header file
+ * (context_hub.h), also used by nanoapp IDs.
+ *
+ * The least significant three bytes are set by the vendor, but must be
+ * unique for each different CHRE implementation/hardware that the vendor
+ * supplies.
+ *
+ * The idea is that in the case of known bugs in the field, a new nanoapp could
+ * be shipped with a workaround that would use this value, and chreGetVersion(),
+ * to have code that can conditionally work around the bug on a buggy version.
+ * Thus, we require this uniqueness to allow such a setup to work.
+ *
+ * @return The platform ID.
+ *
+ * @see CHRE_EXTRACT_VENDOR_ID
+ */
+uint64_t chreGetPlatformId(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_VERSION_H_ */
diff --git a/chre_api/legacy/v1_10/chre/wifi.h b/chre_api/legacy/v1_10/chre/wifi.h
new file mode 100644
index 0000000..44d3d41
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/wifi.h
@@ -0,0 +1,1318 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_WIFI_H_
+#define _CHRE_WIFI_H_
+
+/**
+ * @file
+ * WiFi (IEEE 802.11) API, currently covering scanning features useful for
+ * determining location and offloading certain connectivity scans.
+ *
+ * In this file, specification references use the following shorthand:
+ *
+ * Shorthand | Full specification name
+ * ---------- | ------------------------
+ * "802.11" | IEEE Std 802.11-2007
+ * "HT" | IEEE Std 802.11n-2009
+ * "VHT" | IEEE Std 802.11ac-2013
+ * "WiFi 6" | IEEE Std 802.11ax draft
+ * "NAN" | Wi-Fi Neighbor Awareness Networking (NAN) Technical
+ * Specification (v3.2)
+ *
+ * In the current version of CHRE API, the 6GHz band introduced in WiFi 6 is
+ * not supported. A scan request from CHRE should not result in scanning 6GHz
+ * channels. In particular, if a 6GHz channel is specified in scanning or
+ * ranging request parameter, CHRE should return an error code of
+ * CHRE_ERROR_NOT_SUPPORTED. Additionally, CHRE implementations must not include
+ * observations of access points on 6GHz channels in scan results, especially
+ * those produced due to scan monitoring.
+ */
+
+#include "common.h"
+#include <chre/common.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The set of flags returned by chreWifiGetCapabilities().
+ * @defgroup CHRE_WIFI_CAPABILITIES
+ * @{
+ */
+
+//! No WiFi APIs are supported
+#define CHRE_WIFI_CAPABILITIES_NONE UINT32_C(0)
+
+//! Listening to scan results is supported, as enabled via
+//! chreWifiConfigureScanMonitorAsync()
+#define CHRE_WIFI_CAPABILITIES_SCAN_MONITORING UINT32_C(1 << 0)
+
+//! Requesting WiFi scans on-demand is supported via chreWifiRequestScanAsync()
+#define CHRE_WIFI_CAPABILITIES_ON_DEMAND_SCAN UINT32_C(1 << 1)
+
+//! Specifying the radio chain preference in on-demand scan requests, and
+//! reporting it in scan events is supported
+//! @since v1.2
+#define CHRE_WIFI_CAPABILITIES_RADIO_CHAIN_PREF UINT32_C(1 << 2)
+
+//! Requesting RTT ranging is supported via chreWifiRequestRangingAsync()
+//! @since v1.2
+#define CHRE_WIFI_CAPABILITIES_RTT_RANGING UINT32_C(1 << 3)
+
+//! Specifies if WiFi NAN service subscription is supported. If a platform
+//! supports subscriptions, then it must also support RTT ranging for NAN
+//! services via chreWifiNanRequestRangingAsync()
+//! @since v1.6
+#define CHRE_WIFI_CAPABILITIES_NAN_SUB UINT32_C(1 << 4)
+
+/** @} */
+
+/**
+ * Produce an event ID in the block of IDs reserved for WiFi
+ * @param offset Index into WiFi event ID block; valid range [0,15]
+ */
+#define CHRE_WIFI_EVENT_ID(offset) (CHRE_EVENT_WIFI_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreAsyncResult
+ *
+ * Communicates the asynchronous result of a request to the WiFi API. The
+ * requestType field in {@link #chreAsyncResult} is set to a value from enum
+ * chreWifiRequestType.
+ */
+#define CHRE_EVENT_WIFI_ASYNC_RESULT CHRE_WIFI_EVENT_ID(0)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiScanEvent
+ *
+ * Provides results of a WiFi scan.
+ */
+#define CHRE_EVENT_WIFI_SCAN_RESULT CHRE_WIFI_EVENT_ID(1)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiRangingEvent
+ *
+ * Provides results of an RTT ranging request.
+ */
+#define CHRE_EVENT_WIFI_RANGING_RESULT CHRE_WIFI_EVENT_ID(2)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiNanIdentifierEvent
+ *
+ * Lets the client know if the NAN engine was able to successfully assign
+ * an identifier to the subscribe call. The 'cookie' field in the event
+ * argument struct can be used to track which subscribe request this identifier
+ * maps to.
+ */
+#define CHRE_EVENT_WIFI_NAN_IDENTIFIER_RESULT CHRE_WIFI_EVENT_ID(3)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiNanDiscoveryEvent
+ *
+ * Event that is sent whenever a NAN service matches the criteria specified
+ * in a subscription request.
+ */
+#define CHRE_EVENT_WIFI_NAN_DISCOVERY_RESULT CHRE_WIFI_EVENT_ID(4)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiNanSessionLostEvent
+ *
+ * Informs the client that a discovered service is no longer available or
+ * visible.
+ * The ID of the service on the client that was communicating with the extinct
+ * service is indicated by the event argument.
+ */
+#define CHRE_EVENT_WIFI_NAN_SESSION_LOST CHRE_WIFI_EVENT_ID(5)
+
+/**
+ * nanoappHandleEvent argument: struct chreWifiNanSessionTerminatedEvent
+ *
+ * Signals the end of a NAN subscription session. The termination can be due to
+ * the user turning the WiFi off, or other platform reasons like not being able
+ * to support NAN concurrency with the host. The terminated event will have a
+ * reason code appropriately populated to denote why the event was sent.
+ */
+#define CHRE_EVENT_WIFI_NAN_SESSION_TERMINATED CHRE_WIFI_EVENT_ID(6)
+
+// NOTE: Do not add new events with ID > 15; only values 0-15 are reserved
+// (see chre/event.h)
+
+/**
+ * The maximum amount of time that is allowed to elapse between a call to
+ * chreWifiRequestScanAsync() that returns true, and the associated
+ * CHRE_EVENT_WIFI_ASYNC_RESULT used to indicate whether the scan completed
+ * successfully or not.
+ */
+#define CHRE_WIFI_SCAN_RESULT_TIMEOUT_NS (30 * CHRE_NSEC_PER_SEC)
+
+/**
+ * The maximum amount of time that is allowed to elapse between a call to
+ * chreWifiRequestRangingAsync() that returns true, and the associated
+ * CHRE_EVENT_WIFI_RANGING_RESULT used to indicate whether the ranging operation
+ * completed successfully or not.
+ */
+#define CHRE_WIFI_RANGING_RESULT_TIMEOUT_NS (30 * CHRE_NSEC_PER_SEC)
+
+/**
+ * The current compatibility version of the chreWifiScanEvent structure,
+ * including nested structures.
+ */
+#define CHRE_WIFI_SCAN_EVENT_VERSION UINT8_C(1)
+
+/**
+ * The current compatibility version of the chreWifiRangingEvent structure,
+ * including nested structures.
+ */
+#define CHRE_WIFI_RANGING_EVENT_VERSION UINT8_C(0)
+
+/**
+ * Maximum number of frequencies that can be explicitly specified when
+ * requesting a scan
+ * @see #chreWifiScanParams
+ */
+#define CHRE_WIFI_FREQUENCY_LIST_MAX_LEN (20)
+
+/**
+ * Maximum number of SSIDs that can be explicitly specified when requesting a
+ * scan
+ * @see #chreWifiScanParams
+ */
+#define CHRE_WIFI_SSID_LIST_MAX_LEN (20)
+
+/**
+ * The maximum number of devices that can be specified in a single RTT ranging
+ * request.
+ * @see #chreWifiRangingParams
+ */
+#define CHRE_WIFI_RANGING_LIST_MAX_LEN (10)
+
+/**
+ * The maximum number of octets in an SSID (see 802.11 7.3.2.1)
+ */
+#define CHRE_WIFI_SSID_MAX_LEN (32)
+
+/**
+ * The number of octets in a BSSID (see 802.11 7.1.3.3.3)
+ */
+#define CHRE_WIFI_BSSID_LEN (6)
+
+/**
+ * Set of flags which can either indicate a frequency band. Specified as a bit
+ * mask to allow for combinations in future API versions.
+ * @defgroup CHRE_WIFI_BAND_MASK
+ * @{
+ */
+
+#define CHRE_WIFI_BAND_MASK_2_4_GHZ UINT8_C(1 << 0) //!< 2.4 GHz
+#define CHRE_WIFI_BAND_MASK_5_GHZ UINT8_C(1 << 1) //!< 5 GHz
+
+/** @} */
+
+/**
+ * Characteristics of a scanned device given in struct chreWifiScanResult.flags
+ * @defgroup CHRE_WIFI_SCAN_RESULT_FLAGS
+ * @{
+ */
+
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_NONE UINT8_C(0)
+
+//! Element ID 61 (HT Operation) is present (see HT 7.3.2)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_HT_OPS_PRESENT UINT8_C(1 << 0)
+
+//! Element ID 192 (VHT Operation) is present (see VHT 8.4.2)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_VHT_OPS_PRESENT UINT8_C(1 << 1)
+
+//! Element ID 127 (Extended Capabilities) is present, and bit 70 (Fine Timing
+//! Measurement Responder) is set to 1 (see IEEE Std 802.11-2016 9.4.2.27)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER UINT8_C(1 << 2)
+
+//! Retained for backwards compatibility
+//! @see CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_IS_80211MC_RTT_RESPONDER \
+ CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER
+
+//! HT Operation element indicates that a secondary channel is present
+//! (see HT 7.3.2.57)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_HAS_SECONDARY_CHANNEL_OFFSET UINT8_C(1 << 3)
+
+//! HT Operation element indicates that the secondary channel is below the
+//! primary channel (see HT 7.3.2.57)
+#define CHRE_WIFI_SCAN_RESULT_FLAGS_SECONDARY_CHANNEL_OFFSET_IS_BELOW \
+ UINT8_C(1 << 4)
+
+/** @} */
+
+/**
+ * Identifies the authentication methods supported by an AP. Note that not every
+ * combination of flags may be possible. Based on WIFI_PNO_AUTH_CODE_* from
+ * hardware/libhardware_legacy/include/hardware_legacy/gscan.h in Android.
+ * @defgroup CHRE_WIFI_SECURITY_MODE_FLAGS
+ * @{
+ */
+
+#define CHRE_WIFI_SECURITY_MODE_UNKNOWN UINT8_C(0)
+//! @deprecated since v1.10. Use CHRE_WIFI_SECURITY_MODE_UNKNOWN instead.
+#define CHRE_WIFI_SECURITY_MODE_UNKONWN CHRE_WIFI_SECURITY_MODE_UNKNOWN
+
+#define CHRE_WIFI_SECURITY_MODE_OPEN UINT8_C(1 << 0) //!< No auth/security
+#define CHRE_WIFI_SECURITY_MODE_WEP UINT8_C(1 << 1)
+#define CHRE_WIFI_SECURITY_MODE_PSK UINT8_C(1 << 2) //!< WPA-PSK or WPA2-PSK
+#define CHRE_WIFI_SECURITY_MODE_EAP UINT8_C(1 << 3) //!< WPA-EAP or WPA2-EAP
+
+//! @since v1.5
+#define CHRE_WIFI_SECURITY_MODE_SAE UINT8_C(1 << 4)
+
+//! @since v1.5
+#define CHRE_WIFI_SECURITY_MODE_EAP_SUITE_B UINT8_C(1 << 5)
+
+//! @since v1.5
+#define CHRE_WIFI_SECURITY_MODE_OWE UINT8_C(1 << 6)
+
+/** @} */
+
+/**
+ * Identifies which radio chain was used to discover an AP. The underlying
+ * hardware does not necessarily support more than one radio chain.
+ * @defgroup CHRE_WIFI_RADIO_CHAIN_FLAGS
+ * @{
+ */
+
+#define CHRE_WIFI_RADIO_CHAIN_UNKNOWN UINT8_C(0)
+#define CHRE_WIFI_RADIO_CHAIN_0 UINT8_C(1 << 0)
+#define CHRE_WIFI_RADIO_CHAIN_1 UINT8_C(1 << 1)
+
+/** @} */
+
+//! Special value indicating that an LCI uncertainty fields is not provided
+//! Ref: RFC 6225
+#define CHRE_WIFI_LCI_UNCERTAINTY_UNKNOWN UINT8_C(0)
+
+/**
+ * Defines the flags that may be returned in
+ * {@link #chreWifiRangingResult.flags}. Undefined bits are reserved for future
+ * use and must be ignored by nanoapps.
+ * @defgroup CHRE_WIFI_RTT_RESULT_FLAGS
+ * @{
+ */
+
+//! If set, the nested chreWifiLci structure is populated; otherwise it is
+//! invalid and must be ignored
+#define CHRE_WIFI_RTT_RESULT_HAS_LCI UINT8_C(1 << 0)
+
+/** @} */
+
+/**
+ * Identifies a WiFi frequency band
+ */
+enum chreWifiBand {
+ CHRE_WIFI_BAND_2_4_GHZ = CHRE_WIFI_BAND_MASK_2_4_GHZ,
+ CHRE_WIFI_BAND_5_GHZ = CHRE_WIFI_BAND_MASK_5_GHZ,
+};
+
+/**
+ * Indicates the BSS operating channel width determined from the VHT and/or HT
+ * Operation elements. Refer to VHT 8.4.2.161 and HT 7.3.2.57.
+ */
+enum chreWifiChannelWidth {
+ CHRE_WIFI_CHANNEL_WIDTH_20_MHZ = 0,
+ CHRE_WIFI_CHANNEL_WIDTH_40_MHZ = 1,
+ CHRE_WIFI_CHANNEL_WIDTH_80_MHZ = 2,
+ CHRE_WIFI_CHANNEL_WIDTH_160_MHZ = 3,
+ CHRE_WIFI_CHANNEL_WIDTH_80_PLUS_80_MHZ = 4,
+};
+
+/**
+ * Indicates the type of scan requested or performed
+ */
+enum chreWifiScanType {
+ //! Perform a purely active scan using probe requests. Do not scan channels
+ //! restricted to use via Dynamic Frequency Selection (DFS) only.
+ CHRE_WIFI_SCAN_TYPE_ACTIVE = 0,
+
+ //! Perform an active scan on unrestricted channels, and also perform a
+ //! passive scan on channels that are restricted to use via Dynamic
+ //! Frequency Selection (DFS), e.g. the U-NII bands 5250-5350MHz and
+ //! 5470-5725MHz in the USA as mandated by FCC regulation.
+ CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS = 1,
+
+ //! Perform a passive scan, only listening for beacons.
+ CHRE_WIFI_SCAN_TYPE_PASSIVE = 2,
+
+ //! Client has no preference for a particular scan type.
+ //! Only valid in a {@link #chreWifiScanParams}.
+ //!
+ //! On a v1.4 or earlier platform, this will fall back to
+ //! CHRE_WIFI_SCAN_TYPE_ACTIVE if {@link #chreWifiScanParams.channelSet} is
+ //! set to CHRE_WIFI_CHANNEL_SET_NON_DFS, and to
+ //! CHRE_WIFI_SCAN_TYPE_ACTIVE_PLUS_PASSIVE_DFS otherwise.
+ //!
+ //! If CHRE_WIFI_CAPABILITIES_RADIO_CHAIN_PREF is supported, a v1.5 or
+ //! later platform shall perform a type of scan optimized for {@link
+ //! #chreWifiScanParams.radioChainPref}.
+ //!
+ //! Clients are strongly encouraged to set this value in {@link
+ //! #chreWifiScanParams.scanType} and instead express their preferences
+ //! through {@link #chreWifiRadioChainPref} and {@link #chreWifiChannelSet}
+ //! so the platform can best optimize power and performance.
+ //!
+ //! @since v1.5
+ CHRE_WIFI_SCAN_TYPE_NO_PREFERENCE = 3,
+};
+
+/**
+ * Indicates whether RTT ranging with a specific device succeeded
+ */
+enum chreWifiRangingStatus {
+ //! Ranging completed successfully
+ CHRE_WIFI_RANGING_STATUS_SUCCESS = 0,
+
+ //! Ranging failed due to an unspecified error
+ CHRE_WIFI_RANGING_STATUS_ERROR = 1,
+};
+
+/**
+ * Possible values for {@link #chreWifiLci.altitudeType}. Ref: RFC 6225 2.4
+ */
+enum chreWifiLciAltitudeType {
+ CHRE_WIFI_LCI_ALTITUDE_TYPE_UNKNOWN = 0,
+ CHRE_WIFI_LCI_ALTITUDE_TYPE_METERS = 1,
+ CHRE_WIFI_LCI_ALTITUDE_TYPE_FLOORS = 2,
+};
+
+/**
+ * Indicates a type of request made in this API. Used to populate the resultType
+ * field of struct chreAsyncResult sent with CHRE_EVENT_WIFI_ASYNC_RESULT.
+ */
+enum chreWifiRequestType {
+ CHRE_WIFI_REQUEST_TYPE_CONFIGURE_SCAN_MONITOR = 1,
+ CHRE_WIFI_REQUEST_TYPE_REQUEST_SCAN = 2,
+ CHRE_WIFI_REQUEST_TYPE_RANGING = 3,
+ CHRE_WIFI_REQUEST_TYPE_NAN_SUBSCRIBE = 4,
+};
+
+/**
+ * Allows a nanoapp to express its preference for how multiple available
+ * radio chains should be used when performing an on-demand scan. This is only a
+ * preference from the nanoapp and is not guaranteed to be honored by the WiFi
+ * firmware.
+ */
+enum chreWifiRadioChainPref {
+ //! No preference for radio chain usage
+ CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT = 0,
+
+ //! In a scan result, indicates that the radio chain preference used for the
+ //! scan is not known
+ CHRE_WIFI_RADIO_CHAIN_PREF_UNKNOWN = CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT,
+
+ //! Prefer to use available radio chains in a way that minimizes time to
+ //! complete the scan
+ CHRE_WIFI_RADIO_CHAIN_PREF_LOW_LATENCY = 1,
+
+ //! Prefer to use available radio chains in a way that minimizes total power
+ //! consumed for the scan
+ CHRE_WIFI_RADIO_CHAIN_PREF_LOW_POWER = 2,
+
+ //! Prefer to use available radio chains in a way that maximizes accuracy of
+ //! the scan result, e.g. RSSI measurements
+ CHRE_WIFI_RADIO_CHAIN_PREF_HIGH_ACCURACY = 3,
+};
+
+/**
+ * WiFi NAN subscription type.
+ */
+enum chreWifiNanSubscribeType {
+ //! In the active mode, explicit transmission of a subscribe message is
+ //! requested, and publish messages are processed.
+ CHRE_WIFI_NAN_SUBSCRIBE_TYPE_ACTIVE = 0,
+
+ //! In the passive mode, no transmission of a subscribe message is
+ //! requested, but received publish messages are checked for matches.
+ CHRE_WIFI_NAN_SUBSCRIBE_TYPE_PASSIVE = 1,
+};
+
+/**
+ * Indicates the reason for a subscribe session termination.
+ */
+enum chreWifiNanTerminatedReason {
+ CHRE_WIFI_NAN_TERMINATED_BY_USER_REQUEST = 0,
+ CHRE_WIFI_NAN_TERMINATED_BY_TIMEOUT = 1,
+ CHRE_WIFI_NAN_TERMINATED_BY_FAILURE = 2,
+};
+
+/**
+ * SSID with an explicit length field, used when an array of SSIDs is supplied.
+ */
+struct chreWifiSsidListItem {
+ //! Number of valid bytes in ssid. Valid range [0, CHRE_WIFI_SSID_MAX_LEN]
+ uint8_t ssidLen;
+
+ //! Service Set Identifier (SSID)
+ uint8_t ssid[CHRE_WIFI_SSID_MAX_LEN];
+};
+
+/**
+ * Indicates the set of channels to be scanned.
+ *
+ * @since v1.5
+ */
+enum chreWifiChannelSet {
+ //! The set of channels that allows active scan using probe request.
+ CHRE_WIFI_CHANNEL_SET_NON_DFS = 0,
+
+ //! The set of all channels supported.
+ CHRE_WIFI_CHANNEL_SET_ALL = 1,
+};
+
+/**
+ * Data structure passed to chreWifiRequestScanAsync
+ */
+struct chreWifiScanParams {
+ //! Set to a value from @ref enum chreWifiScanType
+ uint8_t scanType;
+
+ //! Indicates whether the client is willing to tolerate receiving cached
+ //! results of a previous scan, and if so, the maximum age of the scan that
+ //! the client will accept. "Age" in this case is defined as the elapsed
+ //! time between when the most recent scan was completed and the request is
+ //! received, in milliseconds. If set to 0, no cached results may be
+ //! provided, and all scan results must come from a "fresh" WiFi scan, i.e.
+ //! one that completes strictly after this request is received. If more than
+ //! one scan is cached and meets this age threshold, only the newest scan is
+ //! provided.
+ uint32_t maxScanAgeMs;
+
+ //! If set to 0, scan all frequencies. Otherwise, this indicates the number
+ //! of frequencies to scan, as specified in the frequencyList array. Valid
+ //! range [0, CHRE_WIFI_FREQUENCY_LIST_MAX_LEN].
+ uint16_t frequencyListLen;
+
+ //! Pointer to an array of frequencies to scan, given as channel center
+ //! frequencies in MHz. This field may be NULL if frequencyListLen is 0.
+ const uint32_t *frequencyList;
+
+ //! If set to 0, do not restrict scan to any SSIDs. Otherwise, this
+ //! indicates the number of SSIDs in the ssidList array to be used for
+ //! directed probe requests. Not applicable and ignore when scanType is
+ //! CHRE_WIFI_SCAN_TYPE_PASSIVE.
+ uint8_t ssidListLen;
+
+ //! Pointer to an array of SSIDs to use for directed probe requests. May be
+ //! NULL if ssidListLen is 0.
+ const struct chreWifiSsidListItem *ssidList;
+
+ //! Set to a value from enum chreWifiRadioChainPref to specify the desired
+ //! trade-off between power consumption, accuracy, etc. If
+ //! chreWifiGetCapabilities() does not have the applicable bit set, this
+ //! parameter is ignored.
+ //! @since v1.2
+ uint8_t radioChainPref;
+
+ //! Set to a value from enum chreWifiChannelSet to specify the set of
+ //! channels to be scanned. This field is considered by the platform only
+ //! if scanType is CHRE_WIFI_SCAN_TYPE_NO_PREFERENCE and frequencyListLen
+ //! is equal to zero.
+ //!
+ //! @since v1.5
+ uint8_t channelSet;
+};
+
+/**
+ * Provides information about a single access point (AP) detected in a scan.
+ */
+struct chreWifiScanResult {
+ //! Number of milliseconds prior to referenceTime in the enclosing
+ //! chreWifiScanEvent struct when the probe response or beacon frame that
+ //! was used to populate this structure was received.
+ uint32_t ageMs;
+
+ //! Capability Information field sent by the AP (see 802.11 7.3.1.4). This
+ //! field must reflect native byte order and bit ordering, such that
+ //! (capabilityInfo & 1) gives the bit for the ESS subfield.
+ uint16_t capabilityInfo;
+
+ //! Number of valid bytes in ssid. Valid range [0, CHRE_WIFI_SSID_MAX_LEN]
+ uint8_t ssidLen;
+
+ //! Service Set Identifier (SSID), a series of 0 to 32 octets identifying
+ //! the access point. Note that this is commonly a human-readable ASCII
+ //! string, but this is not the required encoding per the standard.
+ uint8_t ssid[CHRE_WIFI_SSID_MAX_LEN];
+
+ //! Basic Service Set Identifier (BSSID), represented in big-endian byte
+ //! order, such that the first octet of the OUI is accessed in byte index 0.
+ uint8_t bssid[CHRE_WIFI_BSSID_LEN];
+
+ //! A set of flags from CHRE_WIFI_SCAN_RESULT_FLAGS_*
+ uint8_t flags;
+
+ //! RSSI (Received Signal Strength Indicator), in dBm. Typically negative.
+ //! If multiple radio chains were used to scan this AP, this is a "best
+ //! available" measure that may be a composite of measurements taken across
+ //! the radio chains.
+ int8_t rssi;
+
+ //! Operating band, set to a value from enum chreWifiBand
+ uint8_t band;
+
+ /**
+ * Indicates the center frequency of the primary 20MHz channel, given in
+ * MHz. This value is derived from the channel number via the formula:
+ *
+ * primaryChannel (MHz) = CSF + 5 * primaryChannelNumber
+ *
+ * Where CSF is the channel starting frequency (in MHz) given by the
+ * operating class/band (i.e. 2407 or 5000), and primaryChannelNumber is the
+ * channel number in the range [1, 200].
+ *
+ * Refer to VHT 22.3.14.
+ */
+ uint32_t primaryChannel;
+
+ /**
+ * If the channel width is 20 MHz, this field is not relevant and set to 0.
+ * If the channel width is 40, 80, or 160 MHz, then this denotes the channel
+ * center frequency (in MHz). If the channel is 80+80 MHz, then this denotes
+ * the center frequency of segment 0, which contains the primary channel.
+ * This value is derived from the frequency index using the same formula as
+ * for primaryChannel.
+ *
+ * Refer to VHT 8.4.2.161, and VHT 22.3.14.
+ *
+ * @see #primaryChannel
+ */
+ uint32_t centerFreqPrimary;
+
+ /**
+ * If the channel width is 80+80MHz, then this denotes the center frequency
+ * of segment 1, which does not contain the primary channel. Otherwise, this
+ * field is not relevant and set to 0.
+ *
+ * @see #centerFreqPrimary
+ */
+ uint32_t centerFreqSecondary;
+
+ //! @see #chreWifiChannelWidth
+ uint8_t channelWidth;
+
+ //! Flags from CHRE_WIFI_SECURITY_MODE_* indicating supported authentication
+ //! and associated security modes
+ //! @see CHRE_WIFI_SECURITY_MODE_FLAGS
+ uint8_t securityMode;
+
+ //! Identifies the radio chain(s) used to discover this AP
+ //! @see CHRE_WIFI_RADIO_CHAIN_FLAGS
+ //! @since v1.2
+ uint8_t radioChain;
+
+ //! If the CHRE_WIFI_RADIO_CHAIN_0 bit is set in radioChain, gives the RSSI
+ //! measured on radio chain 0 in dBm; otherwise invalid and set to 0. This
+ //! field, along with its relative rssiChain1, can be used to determine RSSI
+ //! measurements from each radio chain when multiple chains were used to
+ //! discover this AP.
+ //! @see #radioChain
+ //! @since v1.2
+ int8_t rssiChain0;
+ int8_t rssiChain1; //!< @see #rssiChain0
+
+ //! Reserved; set to 0
+ uint8_t reserved[7];
+};
+
+/**
+ * Data structure sent with events of type CHRE_EVENT_WIFI_SCAN_RESULT.
+ */
+struct chreWifiScanEvent {
+ //! Indicates the version of the structure, for compatibility purposes.
+ //! Clients do not normally need to worry about this field; the CHRE
+ //! implementation guarantees that the client only receives the structure
+ //! version it expects.
+ uint8_t version;
+
+ //! The number of entries in the results array in this event. The CHRE
+ //! implementation may split scan results across multiple events for memory
+ //! concerns, etc.
+ uint8_t resultCount;
+
+ //! The total number of results returned by the scan. Allows an event
+ //! consumer to identify when it has received all events associated with a
+ //! scan.
+ uint8_t resultTotal;
+
+ //! Sequence number for this event within the series of events comprising a
+ //! complete scan result. Scan events are delivered strictly in order, i.e.
+ //! this is monotonically increasing for the results of a single scan. Valid
+ //! range [0, <number of events for scan> - 1]. The number of events for a
+ //! scan is typically given by
+ //! ceil(resultTotal / <max results per event supported by platform>).
+ uint8_t eventIndex;
+
+ //! A value from enum chreWifiScanType indicating the type of scan performed
+ uint8_t scanType;
+
+ //! If a directed scan was performed to a limited set of SSIDs, then this
+ //! identifies the number of unique SSIDs included in the probe requests.
+ //! Otherwise, this is set to 0, indicating that the scan was not limited by
+ //! SSID. Note that if this is non-zero, the list of SSIDs used is not
+ //! included in the scan event.
+ uint8_t ssidSetSize;
+
+ //! If 0, indicates that all frequencies applicable for the scanType were
+ //! scanned. Otherwise, indicates the number of frequencies scanned, as
+ //! specified in scannedFreqList.
+ uint16_t scannedFreqListLen;
+
+ //! Timestamp when the scan was completed, from the same time base as
+ //! chreGetTime() (in nanoseconds)
+ uint64_t referenceTime;
+
+ //! Pointer to an array containing scannedFreqListLen values comprising the
+ //! set of frequencies that were scanned. Frequencies are specified as
+ //! channel center frequencies in MHz. May be NULL if scannedFreqListLen is
+ //! 0.
+ const uint32_t *scannedFreqList;
+
+ //! Pointer to an array containing resultCount entries. May be NULL if
+ //! resultCount is 0.
+ const struct chreWifiScanResult *results;
+
+ //! Set to a value from enum chreWifiRadioChainPref indicating the radio
+ //! chain preference used for the scan. If the applicable bit is not set in
+ //! chreWifiGetCapabilities(), this will always be set to
+ //! CHRE_WIFI_RADIO_CHAIN_PREF_UNKNOWN.
+ //! @since v1.2
+ uint8_t radioChainPref;
+};
+
+/**
+ * Identifies a device to perform RTT ranging against. These values are normally
+ * populated based on the contents of a scan result.
+ * @see #chreWifiScanResult
+ * @see chreWifiRangingTargetFromScanResult()
+ */
+struct chreWifiRangingTarget {
+ //! Device MAC address, specified in the same byte order as
+ //! {@link #chreWifiScanResult.bssid}
+ uint8_t macAddress[CHRE_WIFI_BSSID_LEN];
+
+ //! Center frequency of the primary 20MHz channel, in MHz
+ //! @see #chreWifiScanResult.primaryChannel
+ uint32_t primaryChannel;
+
+ //! Channel center frequency, in MHz, or 0 if not relevant
+ //! @see #chreWifiScanResult.centerFreqPrimary
+ uint32_t centerFreqPrimary;
+
+ //! Channel center frequency of segment 1 if channel width is 80+80MHz,
+ //! otherwise 0
+ //! @see #chreWifiScanResult.centerFreqSecondary
+ uint32_t centerFreqSecondary;
+
+ //! @see #chreWifiChannelWidth
+ uint8_t channelWidth;
+
+ //! Reserved for future use and ignored by CHRE
+ uint8_t reserved[3];
+};
+
+/**
+ * Parameters for an RTT ("Fine Timing Measurement" in terms of 802.11-2016)
+ * ranging request, supplied to chreWifiRequestRangingAsync().
+ */
+struct chreWifiRangingParams {
+ //! Number of devices to perform ranging against and the length of
+ //! targetList, in range [1, CHRE_WIFI_RANGING_LIST_MAX_LEN].
+ uint8_t targetListLen;
+
+ //! Array of macAddressListLen MAC addresses (e.g. BSSIDs) with which to
+ //! attempt RTT ranging.
+ const struct chreWifiRangingTarget *targetList;
+};
+
+/**
+ * Provides the result of RTT ranging with a single device.
+ */
+struct chreWifiRangingResult {
+ //! Time when the ranging operation on this device was performed, in the
+ //! same time base as chreGetTime() (in nanoseconds)
+ uint64_t timestamp;
+
+ //! MAC address of the device for which ranging was requested
+ uint8_t macAddress[CHRE_WIFI_BSSID_LEN];
+
+ //! Gives the result of ranging to this device. If not set to
+ //! CHRE_WIFI_RANGING_STATUS_SUCCESS, the ranging attempt to this device
+ //! failed, and other fields in this structure may be invalid.
+ //! @see #chreWifiRangingStatus
+ uint8_t status;
+
+ //! The mean RSSI measured during the RTT burst, in dBm. Typically negative.
+ //! If status is not CHRE_WIFI_RANGING_STATUS_SUCCESS, will be set to 0.
+ int8_t rssi;
+
+ //! Estimated distance to the device with the given BSSID, in millimeters.
+ //! Generally the mean of multiple measurements performed in a single burst.
+ //! If status is not CHRE_WIFI_RANGING_STATUS_SUCCESS, will be set to 0.
+ uint32_t distance;
+
+ //! Standard deviation of estimated distance across multiple measurements
+ //! performed in a single RTT burst, in millimeters. If status is not
+ //! CHRE_WIFI_RANGING_STATUS_SUCCESS, will be set to 0.
+ uint32_t distanceStdDev;
+
+ //! Location Configuration Information (LCI) information optionally returned
+ //! during the ranging procedure. Only valid if {@link #flags} has the
+ //! CHRE_WIFI_RTT_RESULT_HAS_LCI bit set. Refer to IEEE 802.11-2016
+ //! 9.4.2.22.10, 11.24.6.7, and RFC 6225 (July 2011) for more information.
+ //! Coordinates are to be interpreted according to the WGS84 datum.
+ struct chreWifiLci {
+ //! Latitude in degrees as 2's complement fixed-point with 25 fractional
+ //! bits, i.e. degrees * 2^25. Ref: RFC 6225 2.3
+ int64_t latitude;
+
+ //! Longitude, same format as {@link #latitude}
+ int64_t longitude;
+
+ //! Altitude represented as a 2's complement fixed-point value with 8
+ //! fractional bits. Interpretation depends on {@link #altitudeType}. If
+ //! UNKNOWN, this field must be ignored. If *METERS, distance relative
+ //! to the zero point in the vertical datum. If *FLOORS, a floor value
+ //! relative to the ground floor, potentially fractional, e.g. to
+ //! indicate mezzanine levels. Ref: RFC 6225 2.4
+ int32_t altitude;
+
+ //! Maximum extent of latitude uncertainty in degrees, decoded via this
+ //! formula: 2 ^ (8 - x) where "x" is the encoded value passed in this
+ //! field. Unknown if set to CHRE_WIFI_LCI_UNCERTAINTY_UNKNOWN.
+ //! Ref: RFC 6225 2.3.2
+ uint8_t latitudeUncertainty;
+
+ //! @see #latitudeUncertainty
+ uint8_t longitudeUncertainty;
+
+ //! Defines how to interpret altitude, set to a value from enum
+ //! chreWifiLciAltitudeType
+ uint8_t altitudeType;
+
+ //! Uncertainty in altitude, decoded via this formula: 2 ^ (21 - x)
+ //! where "x" is the encoded value passed in this field. Unknown if set
+ //! to CHRE_WIFI_LCI_UNCERTAINTY_UNKNOWN. Only applies when altitudeType
+ //! is CHRE_WIFI_LCI_ALTITUDE_TYPE_METERS. Ref: RFC 6225 2.4.5
+ uint8_t altitudeUncertainty;
+ } lci;
+
+ //! Refer to CHRE_WIFI_RTT_RESULT_FLAGS
+ uint8_t flags;
+
+ //! Reserved; set to 0
+ uint8_t reserved[7];
+};
+
+/**
+ * Data structure sent with events of type CHRE_EVENT_WIFI_RANGING_RESULT.
+ */
+struct chreWifiRangingEvent {
+ //! Indicates the version of the structure, for compatibility purposes.
+ //! Clients do not normally need to worry about this field; the CHRE
+ //! implementation guarantees that the client only receives the structure
+ //! version it expects.
+ uint8_t version;
+
+ //! The number of ranging results included in the results array; matches the
+ //! number of MAC addresses specified in the request
+ uint8_t resultCount;
+
+ //! Reserved; set to 0
+ uint8_t reserved[2];
+
+ //! Pointer to an array containing resultCount entries
+ const struct chreWifiRangingResult *results;
+};
+
+/**
+ * Indicates the WiFi NAN capabilities of the device. Must contain non-zero
+ * values if WiFi NAN is supported.
+ */
+struct chreWifiNanCapabilities {
+ //! Maximum length of the match filter arrays (applies to both tx and rx
+ //! match filters).
+ uint32_t maxMatchFilterLength;
+
+ //! Maximum length of the service specific information byte array.
+ uint32_t maxServiceSpecificInfoLength;
+
+ //! Maximum length of the service name. Includes the NULL terminator.
+ uint8_t maxServiceNameLength;
+
+ //! Reserved for future use.
+ uint8_t reserved[3];
+};
+
+/**
+ * Data structure sent with events of type
+ * CHRE_EVENT_WIFI_NAN_IDENTIFIER_RESULT
+ */
+struct chreWifiNanIdentifierEvent {
+ //! A unique ID assigned by the NAN engine for the subscribe request
+ //! associated with the cookie encapsulated in the async result below. The
+ //! ID is set to 0 if there was a request failure in which case the async
+ //! result below contains the appropriate error code indicating the failure
+ //! reason.
+ uint32_t id;
+
+ //! Structure which contains the cookie associated with the publish/
+ //! subscribe request, along with an error code that indicates request
+ //! success or failure.
+ struct chreAsyncResult result;
+};
+
+/**
+ * Indicates the desired configuration for a WiFi NAN ranging request.
+ */
+struct chreWifiNanRangingParams {
+ //! MAC address of the NAN device for which range is to be determined.
+ uint8_t macAddress[CHRE_WIFI_BSSID_LEN];
+};
+
+/**
+ * Configuration parameters specific to the Subscribe Function (Spec 4.1.1.1)
+ */
+struct chreWifiNanSubscribeConfig {
+ //! Indicates the subscribe type, set to a value from @ref
+ //! chreWifiNanSubscribeType.
+ uint8_t subscribeType;
+
+ //! UTF-8 name string that identifies the service/application. Must be NULL
+ //! terminated. Note that the string length cannot be greater than the
+ //! maximum length specified by @ref chreWifiNanCapabilities. No
+ //! restriction is placed on the string case, since the service name
+ //! matching is expected to be case insensitive.
+ const char *service;
+
+ //! An array of bytes (and the associated array length) of service-specific
+ //! information. Note that the array length must be less than the
+ //! maxServiceSpecificInfoLength parameter obtained from the NAN
+ //! capabilities (@see struct chreWifiNanCapabilities).
+ const uint8_t *serviceSpecificInfo;
+ uint32_t serviceSpecificInfoSize;
+
+ //! Ordered sequence of {length | value} pairs that specify match criteria
+ //! beyond the service name. 'length' uses 1 byte, and its value indicates
+ //! the number of bytes of the match criteria that follow. The length of
+ //! the match filter array should not exceed the maximum match filter
+ //! length obtained from @ref chreWifiNanGetCapabilities. When a service
+ //! publish message discovery frame containing the Service ID being
+ //! subscribed to is received, the matching is done as follows:
+ //! Each {length | value} pair in the kth position (1 <= k <= #length-value
+ //! pairs) is compared against the kth {length | value} pair in the
+ //! matching filter field of the publish message.
+ //! - For a kth position {length | value} pair in the rx match filter with
+ //! a length of 0, a match is declared regardless of the tx match filter
+ //! contents.
+ //! - For a kth position {length | value} pair in the rx match with a non-
+ //! zero length, there must be an exact match with the kth position pair
+ //! in the match filter field of the received service descriptor for a
+ //! match to be found.
+ //! Please refer to Appendix H of the NAN spec for examples on matching.
+ //! The match filter length should not exceed the maxMatchFilterLength
+ //! obtained from @ref chreWifiNanCapabilities.
+ const uint8_t *matchFilter;
+ uint32_t matchFilterLength;
+};
+
+/**
+ * Data structure sent with events of type
+ * CHRE_EVENT_WIFI_NAN_DISCOVERY_RESULT.
+ */
+struct chreWifiNanDiscoveryEvent {
+ //! Identifier of the subscribe function instance that requested a
+ //! discovery.
+ uint32_t subscribeId;
+
+ //! Identifier of the publisher on the remote NAN device.
+ uint32_t publishId;
+
+ //! NAN interface address of the publisher
+ uint8_t publisherAddress[CHRE_WIFI_BSSID_LEN];
+
+ //! An array of bytes (and the associated array length) of service-specific
+ //! information. Note that the array length must be less than the
+ //! maxServiceSpecificInfoLength parameter obtained from the NAN
+ //! capabilities (@see struct chreWifiNanCapabilities).
+ const uint8_t *serviceSpecificInfo;
+ uint32_t serviceSpecificInfoSize;
+};
+
+/**
+ * Data structure sent with events of type CHRE_EVENT_WIFI_NAN_SESSION_LOST.
+ */
+struct chreWifiNanSessionLostEvent {
+ //! The original ID (returned by the NAN discovery engine) of the subscriber
+ //! instance.
+ uint32_t id;
+
+ //! The ID of the previously discovered publisher on a peer NAN device that
+ //! is no longer connected.
+ uint32_t peerId;
+};
+
+/**
+ * Data structure sent with events of type
+ * CHRE_EVENT_WIFI_NAN_SESSION_TERMINATED.
+ */
+struct chreWifiNanSessionTerminatedEvent {
+ //! The original ID (returned by the NAN discovery engine) of the subscriber
+ //! instance that was terminated.
+ uint32_t id;
+
+ //! A value that maps to one of the termination reasons in @ref enum
+ //! chreWifiNanTerminatedReason.
+ uint8_t reason;
+
+ //! Reserved for future use.
+ uint8_t reserved[3];
+};
+
+/**
+ * Retrieves a set of flags indicating the WiFi features supported by the
+ * current CHRE implementation. The value returned by this function must be
+ * consistent for the entire duration of the Nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_WIFI_CAPABILITIES_* flags set
+ *
+ * @since v1.1
+ */
+uint32_t chreWifiGetCapabilities(void);
+
+/**
+ * Retrieves device-specific WiFi NAN capabilities, and populates them in
+ * the @ref chreWifiNanCapabilities structure.
+ *
+ * @param capabilities Structure into which the WiFi NAN capabilities of
+ * the device are populated into. Must not be NULL.
+ * @return true if WiFi NAN is supported, false otherwise.
+ *
+ * @since v1.6
+ */
+bool chreWifiNanGetCapabilities(struct chreWifiNanCapabilities *capabilities);
+
+/**
+ * Nanoapps must define CHRE_NANOAPP_USES_WIFI somewhere in their build
+ * system (e.g. Makefile) if the nanoapp needs to use the following WiFi APIs.
+ * In addition to allowing access to these APIs, defining this macro will also
+ * ensure CHRE enforces that all host clients this nanoapp talks to have the
+ * required Android permissions needed to listen to WiFi data by adding metadata
+ * to the nanoapp.
+ */
+#if defined(CHRE_NANOAPP_USES_WIFI) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+/**
+ * Manages a client's request to receive the results of WiFi scans performed for
+ * other purposes, for example scans done to maintain connectivity and scans
+ * requested by other clients. The presence of this request has no effect on the
+ * frequency or configuration of the WiFi scans performed - it is purely a
+ * registration by the client to receive the results of scans that would
+ * otherwise occur normally. This should include all available scan results,
+ * including those that are not normally sent to the applications processor,
+ * such as Preferred Network Offload (PNO) scans. Scan results provided because
+ * of this registration must not contain cached results - they are always
+ * expected to contain the fresh results from a recent scan.
+ *
+ * An active scan monitor subscription must persist across temporary conditions
+ * under which no WiFi scans will be performed, for example if WiFi is
+ * completely disabled via user-controlled settings, or if the WiFi system
+ * restarts independently of CHRE. Likewise, a request to enable a scan monitor
+ * subscription must succeed under normal conditions, even in circumstances
+ * where no WiFi scans will be performed. In these cases, the scan monitor
+ * implementation must produce scan results once the temporary condition is
+ * cleared, for example after WiFi is enabled by the user.
+ *
+ * These scan results are delivered to the Nanoapp's handle event callback using
+ * CHRE_EVENT_WIFI_SCAN_RESULT.
+ *
+ * An active scan monitor subscription is not necessary to receive the results
+ * of an on-demand scan request sent via chreWifiRequestScanAsync(), and it does
+ * not result in duplicate delivery of scan results generated from
+ * chreWifiRequestScanAsync().
+ *
+ * If no monitor subscription is active at the time of a request with
+ * enable=false, it is treated as if an active subscription was successfully
+ * ended.
+ *
+ * The result of this request is delivered asynchronously via an event of type
+ * CHRE_EVENT_WIFI_ASYNC_RESULT. Refer to the note in {@link #chreAsyncResult}
+ * for more details.
+ *
+ * @param enable Set to true to enable monitoring scan results, false to
+ * disable
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires WiFi permission
+ */
+bool chreWifiConfigureScanMonitorAsync(bool enable, const void *cookie);
+
+/**
+ * Sends an on-demand request for WiFi scan results. This may trigger a new
+ * scan, or be entirely serviced from cache, depending on the maxScanAgeMs
+ * parameter.
+ *
+ * This resulting status of this request is delivered asynchronously via an
+ * event of type CHRE_EVENT_WIFI_ASYNC_RESULT. The result must be delivered
+ * within CHRE_WIFI_SCAN_RESULT_TIMEOUT_NS of the this request. Refer to the
+ * note in {@link #chreAsyncResult} for more details.
+ *
+ * A successful result provided in CHRE_EVENT_WIFI_ASYNC_RESULT indicates that
+ * the scan results are ready to be delivered in a subsequent event (or events,
+ * which arrive consecutively without any other scan results in between)
+ * of type CHRE_EVENT_WIFI_SCAN_RESULT.
+ *
+ * WiFi scanning must be disabled if both "WiFi scanning" and "WiFi" settings
+ * are disabled at the Android level. In this case, the CHRE implementation is
+ * expected to return a result with CHRE_ERROR_FUNCTION_DISABLED.
+ *
+ * It is not valid for a client to request a new scan while a result is pending
+ * based on a previous scan request from the same client. In this situation, the
+ * CHRE implementation is expected to return a result with CHRE_ERROR_BUSY.
+ * However, if a scan is currently pending or in progress due to a request from
+ * another client, whether within the CHRE or otherwise, the implementation must
+ * not fail the request for this reason. If the pending scan satisfies the
+ * client's request parameters, then the implementation should use its results
+ * to satisfy the request rather than scheduling a new scan.
+ *
+ * @param params A set of parameters for the scan request. Must not be NULL.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires WiFi permission
+ */
+bool chreWifiRequestScanAsync(const struct chreWifiScanParams *params,
+ const void *cookie);
+
+/**
+ * Convenience function which calls chreWifiRequestScanAsync() with a default
+ * set of scan parameters.
+ *
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires WiFi permission
+ */
+static inline bool chreWifiRequestScanAsyncDefault(const void *cookie) {
+ static const struct chreWifiScanParams params = {
+ /*.scanType=*/ CHRE_WIFI_SCAN_TYPE_NO_PREFERENCE,
+ /*.maxScanAgeMs=*/ 5000, // 5 seconds
+ /*.frequencyListLen=*/ 0,
+ /*.frequencyList=*/ NULL,
+ /*.ssidListLen=*/ 0,
+ /*.ssidList=*/ NULL,
+ /*.radioChainPref=*/ CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT,
+ /*.channelSet=*/ CHRE_WIFI_CHANNEL_SET_NON_DFS
+ };
+ return chreWifiRequestScanAsync(¶ms, cookie);
+}
+
+/**
+ * Issues a request to initiate distance measurements using round-trip time
+ * (RTT), aka Fine Timing Measurement (FTM), to one or more devices identified
+ * by MAC address. Within CHRE, MACs are typically the BSSIDs of scanned APs
+ * that have the CHRE_WIFI_SCAN_RESULT_FLAGS_IS_FTM_RESPONDER flag set.
+ *
+ * This resulting status of this request is delivered asynchronously via an
+ * event of type CHRE_EVENT_WIFI_ASYNC_RESULT. The result must be delivered
+ * within CHRE_WIFI_RANGING_RESULT_TIMEOUT_NS of the this request. Refer to the
+ * note in {@link #chreAsyncResult} for more details.
+ *
+ * WiFi RTT ranging must be disabled if any of the following is true:
+ * - Both "WiFi" and "WiFi Scanning" settings are disabled at the Android level.
+ * - The "Location" setting is disabled at the Android level.
+ * In this case, the CHRE implementation is expected to return a result with
+ * CHRE_ERROR_FUNCTION_DISABLED.
+ *
+ * A successful result provided in CHRE_EVENT_WIFI_ASYNC_RESULT indicates that
+ * the results of ranging will be delivered in a subsequent event of type
+ * CHRE_EVENT_WIFI_RANGING_RESULT. Note that the CHRE_EVENT_WIFI_ASYNC_RESULT
+ * gives an overall status - for example, it is used to indicate failure if the
+ * entire ranging request was rejected because WiFi is disabled. However, it is
+ * valid for this event to indicate success, but RTT ranging to fail for all
+ * requested devices - for example, they may be out of range. Therefore, it is
+ * also necessary to check the status field in {@link #chreWifiRangingResult}.
+ *
+ * @param params Structure containing the parameters of the scan request,
+ * including the list of devices to attempt ranging.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.2
+ * @note Requires WiFi permission
+ */
+bool chreWifiRequestRangingAsync(const struct chreWifiRangingParams *params,
+ const void *cookie);
+
+/**
+ * Helper function to populate an instance of struct chreWifiRangingTarget with
+ * the contents of a scan result provided in struct chreWifiScanResult.
+ * Populates other parameters that are not directly derived from the scan result
+ * with default values.
+ *
+ * @param scanResult The scan result to parse as input
+ * @param rangingTarget The RTT ranging target to populate as output
+ *
+ * @note Requires WiFi permission
+ */
+static inline void chreWifiRangingTargetFromScanResult(
+ const struct chreWifiScanResult *scanResult,
+ struct chreWifiRangingTarget *rangingTarget) {
+ memcpy(rangingTarget->macAddress, scanResult->bssid,
+ sizeof(rangingTarget->macAddress));
+ rangingTarget->primaryChannel = scanResult->primaryChannel;
+ rangingTarget->centerFreqPrimary = scanResult->centerFreqPrimary;
+ rangingTarget->centerFreqSecondary = scanResult->centerFreqSecondary;
+ rangingTarget->channelWidth = scanResult->channelWidth;
+
+ // Note that this is not strictly necessary (CHRE can see which API version
+ // the nanoapp was built against, so it knows to ignore these fields), but
+ // we do it here to keep things nice and tidy
+ memset(rangingTarget->reserved, 0, sizeof(rangingTarget->reserved));
+}
+
+/**
+ * Subscribe to a NAN service.
+ *
+ * Sends a subscription request to the NAN discovery engine with the
+ * specified configuration parameters. If successful, a unique non-zero
+ * subscription ID associated with this instance of the subscription
+ * request is assigned by the NAN discovery engine. The subscription request
+ * is active until explicitly canceled, or if the connection was interrupted.
+ *
+ * Note that CHRE forwards any discovery events that it receives to the
+ * subscribe function instance, and does no duplicate filtering. If
+ * multiple events of the same discovery are undesirable, it is up to the
+ * platform NAN discovery engine implementation to implement redundancy
+ * detection mechanisms.
+ *
+ * If WiFi is turned off by the user at the Android level, an existing
+ * subscribe session is canceled, and a CHRE_EVENT_WIFI_ASYNC_RESULT event is
+ * event is sent to the subscriber. Nanoapps are expected to register for user
+ * settings notifications (@see chreUserSettingConfigureEvents), and
+ * re-establish a subscribe session on a WiFi re-enabled settings changed
+ * notification.
+ *
+ * @param config Service subscription configuration
+ * @param cookie A value that the nanoapp uses to track this particular
+ * subscription request.
+ * @return true if NAN is enabled and a subscription request was successfully
+ * made to the NAN engine. The actual result of the service discovery
+ * is sent via a CHRE_EVENT_WIFI_NAN_DISCOVERY_RESULT event.
+ *
+ * @since v1.6
+ * @note Requires WiFi permission
+ */
+bool chreWifiNanSubscribe(struct chreWifiNanSubscribeConfig *config,
+ const void *cookie);
+
+/**
+ * Cancel a subscribe function instance.
+ *
+ * @param subscriptionId The ID that was originally assigned to this instance
+ * of the subscribe function.
+ * @return true if NAN is enabled, the subscribe ID was found and the instance
+ * successfully canceled.
+ *
+ * @since v1.6
+ * @note Requires WiFi permission
+ */
+bool chreWifiNanSubscribeCancel(uint32_t subscriptionID);
+
+/**
+ * Request RTT ranging from a peer NAN device.
+ *
+ * Nanoapps can use this API to explicitly request measurement reports from
+ * the peer device. Note that both end points have to support ranging for a
+ * successful request. The MAC address of the peer NAN device for which ranging
+ * is desired may be obtained either from a NAN service discovery or from an
+ * out-of-band source (HAL service, BLE, etc.).
+ *
+ * If WiFi is turned off by the user at the Android level, an existing
+ * ranging session is canceled, and a CHRE_EVENT_WIFI_ASYNC_RESULT event is
+ * sent to the subscriber. Nanoapps are expected to register for user settings
+ * notifications (@see chreUserSettingConfigureEvents), and perform another
+ * ranging request on a WiFi re-enabled settings changed notification.
+ *
+ * A successful result provided in CHRE_EVENT_WIFI_ASYNC_RESULT indicates that
+ * the results of ranging will be delivered in a subsequent event of type
+ * CHRE_EVENT_WIFI_RANGING_RESULT.
+ *
+ * @param params Structure containing the parameters of the ranging request,
+ * including the MAC address of the peer NAN device to attempt ranging.
+ * @param cookie An opaque value that will be included in the chreAsyncResult
+ * sent in relation to this request.
+ * @return true if the request was accepted for processing, false otherwise.
+ */
+bool chreWifiNanRequestRangingAsync(const struct chreWifiNanRangingParams *params,
+ const void *cookie);
+
+#else /* defined(CHRE_NANOAPP_USES_WIFI) || !defined(CHRE_IS_NANOAPP_BUILD) */
+#define CHRE_WIFI_PERM_ERROR_STRING \
+ "CHRE_NANOAPP_USES_WIFI must be defined when building this nanoapp in " \
+ "order to refer to "
+#define chreWifiConfigureScanMonitorAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING \
+ "chreWifiConfigureScanMonitorAsync")
+#define chreWifiRequestScanAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING \
+ "chreWifiRequestScanAsync")
+#define chreWifiRequestScanAsyncDefault(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING \
+ "chreWifiRequestScanAsyncDefault")
+#define chreWifiRequestRangingAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING "chreWifiRequestRangingAsync")
+#define chreWifiRangingTargetFromScanResult(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING \
+ "chreWifiRangingTargetFromScanResult")
+#define chreWifiNanSubscribe(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING "chreWifiNanSubscribe")
+#define chreWifiNanSubscribeCancel(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING "chreWifiNanSubscribeCancel")
+#define chreWifiNanRequestRangingAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_WIFI_PERM_ERROR_STRING "chreWifiNanRequestRangingAsync")
+#endif /* defined(CHRE_NANOAPP_USES_WIFI) || !defined(CHRE_IS_NANOAPP_BUILD) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_WIFI_H_ */
diff --git a/chre_api/legacy/v1_10/chre/wwan.h b/chre_api/legacy/v1_10/chre/wwan.h
new file mode 100644
index 0000000..dc46182
--- /dev/null
+++ b/chre_api/legacy/v1_10/chre/wwan.h
@@ -0,0 +1,594 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// IWYU pragma: private, include "chre_api/chre.h"
+// IWYU pragma: friend chre/.*\.h
+
+#ifndef _CHRE_WWAN_H_
+#define _CHRE_WWAN_H_
+
+/**
+ * @file
+ * Wireless Wide Area Network (WWAN, i.e. mobile/cellular network) API relevant
+ * for querying cell tower identity and associated information that can be
+ * useful in determining location.
+ *
+ * Based on Android N RIL definitions (located at this path as of the time of
+ * this comment: hardware/ril/include/telephony/ril.h), version 12. Updated
+ * based on Android radio HAL definition (hardware/interfaces/radio) for more
+ * recent Android builds. Refer to those files and associated documentation for
+ * further details.
+ *
+ * In general, the parts of this API that are taken from the RIL follow the
+ * field naming conventions established in that interface rather than the CHRE
+ * API conventions, in order to avoid confusion and enable code re-use where
+ * applicable. Note that structure names include the chreWwan* prefix rather
+ * than RIL_*, but field names are the same. If necessary to enable code
+ * sharing, it is recommended to create typedefs that map from the CHRE
+ * structures to the associated RIL type names, for example "typedef struct
+ * chreWwanCellIdentityGsm RIL_CellIdentityGsm_v12", etc.
+ */
+
+#include <chre/common.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The set of flags returned by chreWwanGetCapabilities().
+ * @defgroup CHRE_WWAN_CAPABILITIES
+ * @{
+ */
+
+//! No WWAN APIs are supported
+#define CHRE_WWAN_CAPABILITIES_NONE UINT32_C(0)
+
+//! Current cell information can be queried via chreWwanGetCellInfoAsync()
+#define CHRE_WWAN_GET_CELL_INFO UINT32_C(1 << 0)
+
+/** @} */
+
+/**
+ * Produce an event ID in the block of IDs reserved for WWAN
+ * @param offset Index into WWAN event ID block; valid range [0,15]
+ */
+#define CHRE_WWAN_EVENT_ID(offset) (CHRE_EVENT_WWAN_FIRST_EVENT + (offset))
+
+/**
+ * nanoappHandleEvent argument: struct chreWwanCellInfoResult
+ *
+ * Provides the result of an asynchronous request for cell info sent via
+ * chreWwanGetCellInfoAsync().
+ */
+#define CHRE_EVENT_WWAN_CELL_INFO_RESULT CHRE_WWAN_EVENT_ID(0)
+
+// NOTE: Do not add new events with ID > 15; only values 0-15 are reserved
+// (see chre/event.h)
+
+/**
+ * The current version of struct chreWwanCellInfoResult associated with this
+ * API definition.
+ */
+#define CHRE_WWAN_CELL_INFO_RESULT_VERSION UINT8_C(1)
+
+//! Reference: RIL_CellIdentityGsm_v12
+struct chreWwanCellIdentityGsm {
+ //! 3-digit Mobile Country Code, 0..999, INT32_MAX if unknown
+ int32_t mcc;
+
+ //! 2 or 3-digit Mobile Network Code, 0..999, INT32_MAX if unknown
+ int32_t mnc;
+
+ //! 16-bit Location Area Code, 0..65535, INT32_MAX if unknown
+ int32_t lac;
+
+ //! 16-bit GSM Cell Identity described in TS 27.007, 0..65535,
+ //! INT32_MAX if unknown
+ int32_t cid;
+
+ //! 16-bit GSM Absolute RF channel number, INT32_MAX if unknown
+ int32_t arfcn;
+
+ //! 6-bit Base Station Identity Code, UINT8_MAX if unknown
+ uint8_t bsic;
+
+ //! Reserved for future use; must be set to 0
+ uint8_t reserved[3];
+};
+
+//! Reference: RIL_CellIdentityWcdma_v12
+struct chreWwanCellIdentityWcdma {
+ //! 3-digit Mobile Country Code, 0..999, INT32_MAX if unknown
+ int32_t mcc;
+
+ //! 2 or 3-digit Mobile Network Code, 0..999, INT32_MAX if unknown
+ int32_t mnc;
+
+ //! 16-bit Location Area Code, 0..65535, INT32_MAX if unknown
+ int32_t lac;
+
+ //! 28-bit UMTS Cell Identity described in TS 25.331, 0..268435455,
+ //! INT32_MAX if unknown
+ int32_t cid;
+
+ //! 9-bit UMTS Primary Scrambling Code described in TS 25.331, 0..511,
+ //! INT32_MAX if unknown
+ int32_t psc;
+
+ //! 16-bit UMTS Absolute RF Channel Number, INT32_MAX if unknown
+ int32_t uarfcn;
+};
+
+//! Reference: RIL_CellIdentityCdma
+struct chreWwanCellIdentityCdma {
+ //! Network Id 0..65535, INT32_MAX if unknown
+ int32_t networkId;
+
+ //! CDMA System Id 0..32767, INT32_MAX if unknown
+ int32_t systemId;
+
+ //! Base Station Id 0..65535, INT32_MAX if unknown
+ int32_t basestationId;
+
+ //! Longitude is a decimal number as specified in 3GPP2 C.S0005-A v6.0.
+ //! It is represented in units of 0.25 seconds and ranges from -2592000
+ //! to 2592000, both values inclusive (corresponding to a range of -180
+ //! to +180 degrees). INT32_MAX if unknown
+ int32_t longitude;
+
+ //! Latitude is a decimal number as specified in 3GPP2 C.S0005-A v6.0.
+ //! It is represented in units of 0.25 seconds and ranges from -1296000
+ //! to 1296000, both values inclusive (corresponding to a range of -90
+ //! to +90 degrees). INT32_MAX if unknown
+ int32_t latitude;
+};
+
+//! Reference: RIL_CellIdentityLte_v12
+struct chreWwanCellIdentityLte {
+ //! 3-digit Mobile Country Code, 0..999, INT32_MAX if unknown
+ int32_t mcc;
+
+ //! 2 or 3-digit Mobile Network Code, 0..999, INT32_MAX if unknown
+ int32_t mnc;
+
+ //! 28-bit Cell Identity described in TS ???, INT32_MAX if unknown
+ int32_t ci;
+
+ //! physical cell id 0..503, INT32_MAX if unknown
+ int32_t pci;
+
+ //! 16-bit tracking area code, INT32_MAX if unknown
+ int32_t tac;
+
+ //! 18-bit LTE Absolute RF Channel Number, INT32_MAX if unknown
+ int32_t earfcn;
+};
+
+//! Reference: RIL_CellIdentityTdscdma
+struct chreWwanCellIdentityTdscdma {
+ //! 3-digit Mobile Country Code, 0..999, INT32_MAX if unknown
+ int32_t mcc;
+
+ //! 2 or 3-digit Mobile Network Code, 0..999, INT32_MAX if unknown
+ int32_t mnc;
+
+ //! 16-bit Location Area Code, 0..65535, INT32_MAX if unknown
+ int32_t lac;
+
+ //! 28-bit UMTS Cell Identity described in TS 25.331, 0..268435455,
+ //! INT32_MAX if unknown
+ int32_t cid;
+
+ //! 8-bit Cell Parameters ID described in TS 25.331, 0..127, INT32_MAX if
+ //! unknown
+ int32_t cpid;
+};
+
+//! Reference: android.hardware.radio@1.4 CellIdentityNr
+//! @since v1.4
+struct chreWwanCellIdentityNr {
+ //! 3-digit Mobile Country Code, in range [0, 999]. This value must be valid
+ //! for registered or camped cells. INT32_MAX means invalid/unreported.
+ int32_t mcc;
+
+ //! 2 or 3-digit Mobile Network Code, in range [0, 999]. This value must be
+ //! valid for registered or camped cells. INT32_MAX means
+ //! invalid/unreported.
+ int32_t mnc;
+
+ //! NR Cell Identity in range [0, 68719476735] (36 bits), which
+ //! unambiguously identifies a cell within a public land mobile network
+ //! (PLMN). This value must be valid for registered or camped cells.
+ //! Reference: TS 38.413 section 9.3.1.7.
+ //!
+ //! Note: for backward compatibility reasons, the nominally int64_t nci is
+ //! split into two uint32_t values, with nci0 being the least significant 4
+ //! bytes. If chreWwanUnpackNrNci returns INT64_MAX, it means nci is
+ //! invalid/unreported.
+ //!
+ //! Users are recommended to use the helper accessor chreWwanUnpackNrNci to
+ //! access the nci field.
+ //!
+ //! @see chreWwanUnpackNrNci
+ uint32_t nci0;
+ uint32_t nci1;
+
+ //! Physical cell id in range [0, 1007]. This value must be valid.
+ //! Reference: TS 38.331 section 6.3.2.
+ int32_t pci;
+
+ //! 24-bit tracking area code in range [0, 16777215]. INT32_MAX means
+ //! invalid/unreported.
+ //! Reference: TS 38.413 section 9.3.3.10 and TS 29.571 section 5.4.2.
+ int32_t tac;
+
+ //! NR Absolute Radio Frequency Channel Number, in range [0, 3279165]. This
+ //! value must be valid.
+ //! Reference: TS 38.101-1 section 5.4.2.1 and TS 38.101-2 section 5.4.2.1.
+ int32_t nrarfcn;
+};
+
+//! Reference: RIL_GSM_SignalStrength_v12
+struct chreWwanSignalStrengthGsm {
+ //! Valid values are (0-31, 99) as defined in TS 27.007 8.5
+ //! INT32_MAX means invalid/unreported.
+ int32_t signalStrength;
+
+ //! bit error rate (0-7, 99) as defined in TS 27.007 8.5
+ //! INT32_MAX means invalid/unreported.
+ int32_t bitErrorRate;
+
+ //! Timing Advance in bit periods. 1 bit period = 48.13 us.
+ //! INT32_MAX means invalid/unreported.
+ int32_t timingAdvance;
+};
+
+//! Reference: RIL_SignalStrengthWcdma
+struct chreWwanSignalStrengthWcdma {
+ //! Valid values are (0-31, 99) as defined in TS 27.007 8.5
+ //! INT32_MAX means invalid/unreported.
+ int32_t signalStrength;
+
+ //! bit error rate (0-7, 99) as defined in TS 27.007 8.5
+ //! INT32_MAX means invalid/unreported.
+ int32_t bitErrorRate;
+};
+
+//! Reference: RIL_CDMA_SignalStrength
+struct chreWwanSignalStrengthCdma {
+ //! Valid values are positive integers. This value is the actual RSSI value
+ //! multiplied by -1. Example: If the actual RSSI is -75, then this
+ //! response value will be 75.
+ //! INT32_MAX means invalid/unreported.
+ int32_t dbm;
+
+ //! Valid values are positive integers. This value is the actual Ec/Io
+ //! multiplied by -10. Example: If the actual Ec/Io is -12.5 dB, then this
+ //! response value will be 125.
+ //! INT32_MAX means invalid/unreported.
+ int32_t ecio;
+};
+
+//! Reference: RIL_EVDO_SignalStrength
+struct chreWwanSignalStrengthEvdo {
+ //! Valid values are positive integers. This value is the actual RSSI value
+ //! multiplied by -1. Example: If the actual RSSI is -75, then this
+ //! response value will be 75.
+ //! INT32_MAX means invalid/unreported.
+ int32_t dbm;
+
+ //! Valid values are positive integers. This value is the actual Ec/Io
+ //! multiplied by -10. Example: If the actual Ec/Io is -12.5 dB, then this
+ //! response value will be 125.
+ //! INT32_MAX means invalid/unreported.
+ int32_t ecio;
+
+ //! Valid values are 0-8. 8 is the highest signal to noise ratio.
+ //! INT32_MAX means invalid/unreported.
+ int32_t signalNoiseRatio;
+};
+
+//! Reference: RIL_LTE_SignalStrength_v8
+struct chreWwanSignalStrengthLte {
+ //! Valid values are (0-31, 99) as defined in TS 27.007 8.5
+ int32_t signalStrength;
+
+ //! The current Reference Signal Receive Power in dBm multiplied by -1.
+ //! Range: 44 to 140 dBm
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP TS 36.133 9.1.4
+ int32_t rsrp;
+
+ //! The current Reference Signal Receive Quality in dB multiplied by -1.
+ //! Range: 3 to 20 dB.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP TS 36.133 9.1.7
+ int32_t rsrq;
+
+ //! The current reference signal signal-to-noise ratio in 0.1 dB units.
+ //! Range: -200 to +300 (-200 = -20.0 dB, +300 = 30dB).
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP TS 36.101 8.1.1
+ int32_t rssnr;
+
+ //! The current Channel Quality Indicator.
+ //! Range: 0 to 15.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP TS 36.101 9.2, 9.3, A.4
+ int32_t cqi;
+
+ //! timing advance in micro seconds for a one way trip from cell to device.
+ //! Approximate distance can be calculated using 300m/us * timingAdvance.
+ //! Range: 0 to 0x7FFFFFFE
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP 36.321 section 6.1.3.5
+ //! also: http://www.cellular-planningoptimization.com/2010/02/timing-advance-with-calculation.html
+ int32_t timingAdvance;
+};
+
+//! Reference: RIL_TD_SCDMA_SignalStrength
+struct chreWwanSignalStrengthTdscdma {
+ //! The Received Signal Code Power in dBm multiplied by -1.
+ //! Range : 25 to 120
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: 3GPP TS 25.123, section 9.1.1.1
+ int32_t rscp;
+};
+
+//! Reference: android.hardware.radio@1.4 NrSignalStrength
+//! @since v1.4
+struct chreWwanSignalStrengthNr {
+ //! SS (second synchronization) reference signal received power in dBm
+ //! multiplied by -1.
+ //! Range [44, 140], INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.1 and TS 38.133 section 10.1.6.
+ int32_t ssRsrp;
+
+ //! SS reference signal received quality in 0.5 dB units.
+ //! Range [-86, 41] with -86 = -43.0 dB and 41 = 20.5 dB.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.3 and TS 38.133 section 10.1.11.1.
+ int32_t ssRsrq;
+
+ //! SS signal-to-noise and interference ratio in 0.5 dB units.
+ //! Range [-46, 81] with -46 = -23.0 dB and 81 = 40.5 dB.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.5 and TS 38.133 section 10.1.16.1.
+ int32_t ssSinr;
+
+ //! CSI reference signal received power in dBm multiplied by -1.
+ //! Range [44, 140], INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.2 and TS 38.133 section 10.1.6.
+ int32_t csiRsrp;
+
+ //! CSI reference signal received quality in 0.5 dB units.
+ //! Range [-86, 41] with -86 = -43.0 dB and 41 = 20.5 dB.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.4 and TS 38.133 section 10.1.11.1.
+ int32_t csiRsrq;
+
+ //! CSI signal-to-noise and interference ratio in 0.5 dB units.
+ //! Range [-46, 81] with -46 = -23.0 dB and 81 = 40.5 dB.
+ //! INT32_MAX means invalid/unreported.
+ //! Reference: TS 38.215 section 5.1.6 and TS 38.133 section 10.1.16.1.
+ int32_t csiSinr;
+};
+
+//! Reference: RIL_CellInfoGsm_v12
+struct chreWwanCellInfoGsm {
+ struct chreWwanCellIdentityGsm cellIdentityGsm;
+ struct chreWwanSignalStrengthGsm signalStrengthGsm;
+};
+
+//! Reference: RIL_CellInfoWcdma_v12
+struct chreWwanCellInfoWcdma {
+ struct chreWwanCellIdentityWcdma cellIdentityWcdma;
+ struct chreWwanSignalStrengthWcdma signalStrengthWcdma;
+};
+
+//! Reference: RIL_CellInfoCdma
+struct chreWwanCellInfoCdma {
+ struct chreWwanCellIdentityCdma cellIdentityCdma;
+ struct chreWwanSignalStrengthCdma signalStrengthCdma;
+ struct chreWwanSignalStrengthEvdo signalStrengthEvdo;
+};
+
+//! Reference: RIL_CellInfoLte_v12
+struct chreWwanCellInfoLte {
+ struct chreWwanCellIdentityLte cellIdentityLte;
+ struct chreWwanSignalStrengthLte signalStrengthLte;
+};
+
+//! Reference: RIL_CellInfoTdscdma
+struct chreWwanCellInfoTdscdma {
+ struct chreWwanCellIdentityTdscdma cellIdentityTdscdma;
+ struct chreWwanSignalStrengthTdscdma signalStrengthTdscdma;
+};
+
+//! Reference: android.hardware.radio@1.4 CellInfoNr
+//! @since v1.4
+struct chreWwanCellInfoNr {
+ struct chreWwanCellIdentityNr cellIdentityNr;
+ struct chreWwanSignalStrengthNr signalStrengthNr;
+};
+
+//! Reference: RIL_CellInfoType
+//! All other values are reserved and should be ignored by nanoapps.
+enum chreWwanCellInfoType {
+ CHRE_WWAN_CELL_INFO_TYPE_GSM = 1,
+ CHRE_WWAN_CELL_INFO_TYPE_CDMA = 2,
+ CHRE_WWAN_CELL_INFO_TYPE_LTE = 3,
+ CHRE_WWAN_CELL_INFO_TYPE_WCDMA = 4,
+ CHRE_WWAN_CELL_INFO_TYPE_TD_SCDMA = 5,
+ CHRE_WWAN_CELL_INFO_TYPE_NR = 6, //! @since v1.4
+};
+
+//! Reference: RIL_TimeStampType
+enum chreWwanCellTimeStampType {
+ CHRE_WWAN_CELL_TIMESTAMP_TYPE_UNKNOWN = 0,
+ CHRE_WWAN_CELL_TIMESTAMP_TYPE_ANTENNA = 1,
+ CHRE_WWAN_CELL_TIMESTAMP_TYPE_MODEM = 2,
+ CHRE_WWAN_CELL_TIMESTAMP_TYPE_OEM_RIL = 3,
+ CHRE_WWAN_CELL_TIMESTAMP_TYPE_JAVA_RIL = 4,
+};
+
+//! Reference: RIL_CellInfo_v12
+struct chreWwanCellInfo {
+ //! Timestamp in nanoseconds; must be in the same time base as chreGetTime()
+ uint64_t timeStamp;
+
+ //! A value from enum {@link #CellInfoType} indicating the radio access
+ //! technology of the cell, and which field in union CellInfo can be used
+ //! to retrieve additional information
+ uint8_t cellInfoType;
+
+ //! A value from enum {@link #CellTimeStampType} that identifies the source
+ //! of the value in timeStamp. This is typically set to
+ //! CHRE_WWAN_CELL_TIMESTAMP_TYPE_OEM_RIL, and indicates the time given by
+ //! chreGetTime() that an intermediate module received the data from the
+ //! modem and forwarded it to the requesting CHRE client.
+ uint8_t timeStampType;
+
+ //! !0 if this cell is registered, 0 if not registered
+ uint8_t registered;
+
+ //! Reserved for future use; must be set to 0
+ uint8_t reserved;
+
+ //! The value in cellInfoType indicates which field in this union is valid
+ union chreWwanCellInfoPerRat {
+ struct chreWwanCellInfoGsm gsm;
+ struct chreWwanCellInfoCdma cdma;
+ struct chreWwanCellInfoLte lte;
+ struct chreWwanCellInfoWcdma wcdma;
+ struct chreWwanCellInfoTdscdma tdscdma;
+ struct chreWwanCellInfoNr nr; //! @since v1.4
+ } CellInfo;
+};
+
+/**
+ * Data structure provided with events of type CHRE_EVENT_WWAN_CELL_INFO_RESULT.
+ */
+struct chreWwanCellInfoResult {
+ //! Indicates the version of the structure, for compatibility purposes.
+ //! Clients do not normally need to worry about this field; the CHRE
+ //! implementation guarantees that the client only receives the structure
+ //! version it expects.
+ uint8_t version;
+
+ //! Populated with a value from enum {@link #chreError}, indicating whether
+ //! the request failed, and if so, provides the cause of the failure
+ uint8_t errorCode;
+
+ //! The number of valid entries in cells[]
+ uint8_t cellInfoCount;
+
+ //! Reserved for future use; must be set to 0
+ uint8_t reserved;
+
+ //! Set to the cookie parameter given to chreWwanGetCellInfoAsync()
+ const void *cookie;
+
+ //! Pointer to an array of cellInfoCount elements containing information
+ //! about serving and neighbor cells
+ const struct chreWwanCellInfo *cells;
+};
+
+
+/**
+ * Retrieves a set of flags indicating the WWAN features supported by the
+ * current CHRE implementation. The value returned by this function must be
+ * consistent for the entire duration of the Nanoapp's execution.
+ *
+ * The client must allow for more flags to be set in this response than it knows
+ * about, for example if the implementation supports a newer version of the API
+ * than the client was compiled against.
+ *
+ * @return A bitmask with zero or more CHRE_WWAN_CAPABILITIES_* flags set
+ *
+ * @since v1.1
+ */
+uint32_t chreWwanGetCapabilities(void);
+
+/**
+ * Nanoapps must define CHRE_NANOAPP_USES_WWAN somewhere in their build
+ * system (e.g. Makefile) if the nanoapp needs to use the following WWAN APIs.
+ * In addition to allowing access to these APIs, defining this macro will also
+ * ensure CHRE enforces that all host clients this nanoapp talks to have the
+ * required Android permissions needed to listen to WWAN data by adding metadata
+ * to the nanoapp.
+ */
+#if defined(CHRE_NANOAPP_USES_WWAN) || !defined(CHRE_IS_NANOAPP_BUILD)
+
+/**
+ * Query information about the current serving cell and its neighbors. This does
+ * not perform a network scan, but should return state from the current network
+ * registration data stored in the cellular modem. This is effectively the same
+ * as a request for RIL_REQUEST_GET_CELL_INFO_LIST in the RIL.
+ *
+ * The requested cellular information is returned asynchronously via
+ * CHRE_EVENT_WWAN_CELL_INFO_RESULT. The implementation must send this event,
+ * either with successful data or an error status, within
+ * CHRE_ASYNC_RESULT_TIMEOUT_NS.
+ *
+ * If the airplane mode setting is enabled at the Android level, the CHRE
+ * implementation is expected to return a successful asynchronous result with an
+ * empty cell info list.
+ *
+ * @param cookie An opaque value that will be included in the
+ * chreWwanCellInfoResult sent in relation to this request.
+ *
+ * @return true if the request was accepted for processing, false otherwise
+ *
+ * @since v1.1
+ * @note Requires WWAN permission
+ */
+bool chreWwanGetCellInfoAsync(const void *cookie);
+
+/**
+ * Helper accessor for nci in the chreWwanCellIdentityNr struct.
+ *
+ * @return nci or INT64_MAX if invalid/unreported.
+ *
+ * @see chreWwanCellIdentityNr
+ *
+ * @since v1.4
+ * @note Requires WWAN permission
+ */
+static inline int64_t chreWwanUnpackNrNci(
+ const struct chreWwanCellIdentityNr *nrCellId) {
+ return (int64_t) (((uint64_t) nrCellId->nci1 << 32) | nrCellId->nci0);
+}
+
+#else /* defined(CHRE_NANOAPP_USES_WWAN) || !defined(CHRE_IS_NANOAPP_BUILD) */
+#define CHRE_WWAN_PERM_ERROR_STRING \
+ "CHRE_NANOAPP_USES_WWAN must be defined when building this nanoapp in " \
+ "order to refer to "
+#define chreWwanGetCellInfoAsync(...) \
+ CHRE_BUILD_ERROR(CHRE_WWAN_PERM_ERROR_STRING "chreWwanGetCellInfoAsync")
+#define chreWwanUnpackNrNci(...) \
+ CHRE_BUILD_ERROR(CHRE_WWAN_PERM_ERROR_STRING "chreWwanUnpackNrNci")
+#endif /* defined(CHRE_NANOAPP_USES_WWAN) || !defined(CHRE_IS_NANOAPP_BUILD) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CHRE_WWAN_H_ */
diff --git a/chre_flags.aconfig b/chre_flags.aconfig
index 1fbb459..4348fd4 100644
--- a/chre_flags.aconfig
+++ b/chre_flags.aconfig
@@ -1,13 +1,20 @@
package: "android.chre.flags"
container: "system"
+# Exported flags should remain here indefinitely
+# Flags guarding APIs are exported
+# Begin removed exported flags (keep flag definition)
+
flag {
- name: "context_hub_callback_uuid_enabled"
+ name: "reliable_message"
+ is_exported: true
namespace: "context_hub"
- description: "Call IContextHubCallback.getUuid() to retrieve the UUID when this flag is on"
- bug: "247124878"
+ description: "Enable the reliable message APIs"
+ bug: "314081414"
}
+# End removed exported flags (keep flag definition)
+
flag {
name: "abort_if_no_context_hub_found"
namespace: "context_hub"
@@ -23,21 +30,6 @@
}
flag {
- name: "reliable_message"
- is_exported: true
- namespace: "context_hub"
- description: "Enable the reliable message APIs"
- bug: "314081414"
-}
-
-flag {
- name: "reliable_message_implementation"
- namespace: "context_hub"
- description: "Enable support for reliable messages in CHRE"
- bug: "314081414"
-}
-
-flag {
name: "reliable_message_duplicate_detection_service"
namespace: "context_hub"
description: "Enable duplicate detection for reliable messages in the Context Hub Service"
@@ -96,20 +88,6 @@
}
flag {
- name: "unified_metrics_reporting_api"
- namespace: "context_hub"
- description: "The API for unified metrics reporting in the Context Hub Service"
- bug: "361804033"
-}
-
-flag {
- name: "unified_metrics_reporting_implementation"
- namespace: "context_hub"
- description: "The implementation for unified metrics reporting in the Context Hub Service"
- bug: "361804033"
-}
-
-flag {
name: "reduce_locking_context_hub_transaction_manager"
namespace: "context_hub"
description: "Reduces locking in the ContextHubTransactionManager"
@@ -118,3 +96,55 @@
purpose: PURPOSE_BUGFIX
}
}
+
+flag {
+ name: "offload_api"
+ namespace: "context_hub"
+ description: "Enables the generic offload APIs"
+ bug: "361573382"
+ is_exported: true
+}
+
+flag {
+ name: "offload_implementation"
+ namespace: "context_hub"
+ description: "Enables support for generic offload"
+ bug: "361573382"
+}
+
+flag {
+ name: "efw_xport_rewind_on_error"
+ namespace: "context_hub"
+ description: "Flag guarding the AOC-dependent behavior to rewind to the last good message"
+ bug: "371057943"
+ metadata {
+ purpose: PURPOSE_BUGFIX
+ }
+}
+
+flag {
+ name: "efw_xport_in_context_hub"
+ namespace: "context_hub"
+ description: "Flag guarding the use of the new EFW transport for ContextHub <-> CHRE comms"
+ bug: "369883034"
+}
+
+flag {
+ name: "bug_fix_remove_exit_call_in_hal"
+ namespace: "context_hub"
+ description: "Flag enabling multiclient HAL to gracefully handle connection to CHRE in init/restart"
+ bug: "374773993"
+ metadata {
+ purpose: PURPOSE_BUGFIX
+ }
+}
+
+flag {
+ name: "hal_handle_nanoapp_query_test_mode"
+ namespace: "context_hub"
+ description: "Flag guarding the fix for nanoapp query handling when enabling test mode"
+ bug: "379342519"
+ metadata {
+ purpose: PURPOSE_BUGFIX
+ }
+}
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
new file mode 100644
index 0000000..3d5485f
--- /dev/null
+++ b/core/CMakeLists.txt
@@ -0,0 +1,100 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+pw_add_library(chre.core STATIC
+ HEADERS
+ include/chre/core/host_comms_manager.h
+ include/chre/core/settings.h
+ include/chre/core/audio_request_manager.h
+ include/chre/core/api_manager_common.h
+ include/chre/core/wifi_request_manager.h
+ include/chre/core/event_ref_queue.h
+ include/chre/core/sensor_request_multiplexer.h
+ include/chre/core/audio_util.h
+ include/chre/core/gnss_manager.h
+ include/chre/core/init.h
+ include/chre/core/timer_pool.h
+ include/chre/core/event_loop_common.h
+ include/chre/core/sensor_type.h
+ include/chre/core/wwan_request_manager.h
+ include/chre/core/event_loop.h
+ include/chre/core/sensor_request.h
+ include/chre/core/ble_request_multiplexer.h
+ include/chre/core/static_nanoapps.h
+ include/chre/core/sensor.h
+ include/chre/core/ble_request_manager.h
+ include/chre/core/request_multiplexer.h
+ include/chre/core/event_loop_manager.h
+ include/chre/core/system_health_monitor.h
+ include/chre/core/request_multiplexer_impl.h
+ include/chre/core/debug_dump_manager.h
+ include/chre/core/nanoapp.h
+ include/chre/core/telemetry_manager.h
+ include/chre/core/sensor_type_helpers.h
+ include/chre/core/wifi_scan_request.h
+ include/chre/core/sensor_request_manager.h
+ include/chre/core/event.h
+ include/chre/core/ble_request.h
+ include/chre/core/host_endpoint_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.atomic
+ chre.platform.fatal_error
+ chre.platform.host_link
+ chre.platform.log
+ chre.platform.memory_manager
+ chre.platform.mutex
+ chre.platform.platform_audio
+ chre.platform.platform_ble
+ chre.platform.platform_debug_dump_manager
+ chre.platform.platform_gnss
+ chre.platform.platform_nanoapp
+ chre.platform.platform_sensor
+ chre.platform.platform_sensor_manager
+ chre.platform.platform_sensor_type_helpers
+ chre.platform.platform_wifi
+ chre.platform.platform_wwan
+ chre.platform.power_control_manager
+ chre.platform.system_time
+ chre.platform.system_timer
+ chre.util
+ chre.util.system
+ chre.variant.config
+ pw_function
+ SOURCES
+ audio_request_manager.cc
+ ble_request.cc
+ ble_request_manager.cc
+ ble_request_multiplexer.cc
+ debug_dump_manager.cc
+ event.cc
+ event_loop.cc
+ event_loop_manager.cc
+ event_ref_queue.cc
+ gnss_manager.cc
+ host_comms_manager.cc
+ host_endpoint_manager.cc
+ init.cc
+ nanoapp.cc
+ sensor.cc
+ sensor_request.cc
+ sensor_request_manager.cc
+ sensor_request_multiplexer.cc
+ sensor_type.cc
+ sensor_type_helpers.cc
+ settings.cc
+ static_nanoapps.cc
+ system_health_monitor.cc
+ timer_pool.cc
+ wifi_request_manager.cc
+ wifi_scan_request.cc
+ wwan_request_manager.cc
+ PRIVATE_DEPS
+ chre.platform.context
+ chre.platform.log
+ chre.platform.memory
+ chre.platform.tracing
+ chre.platform.version
+)
diff --git a/core/audio_request_manager.cc b/core/audio_request_manager.cc
index 47c919d..360a3e0 100644
--- a/core/audio_request_manager.cc
+++ b/core/audio_request_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_AUDIO_SUPPORT_ENABLED
+
#include "chre/core/audio_request_manager.h"
#include "chre/core/audio_util.h"
@@ -513,3 +515,5 @@
}
} // namespace chre
+
+#endif // CHRE_AUDIO_SUPPORT_ENABLED
diff --git a/core/ble_request_manager.cc b/core/ble_request_manager.cc
index ed93e3e..577a623 100644
--- a/core/ble_request_manager.cc
+++ b/core/ble_request_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_BLE_SUPPORT_ENABLED
+
#include "chre/core/ble_request_manager.h"
#include "chre/core/event_loop_manager.h"
@@ -716,3 +718,5 @@
}
} // namespace chre
+
+#endif // CHRE_BLE_SUPPORT_ENABLED
diff --git a/core/chre_message_hub_manager.cc b/core/chre_message_hub_manager.cc
new file mode 100644
index 0000000..96ed194
--- /dev/null
+++ b/core/chre_message_hub_manager.cc
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+
+#include "chre/core/chre_message_hub_manager.h"
+#include "chre/core/event_loop_common.h"
+#include "chre/core/event_loop_manager.h"
+#include "chre/core/nanoapp.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router.h"
+#include "chre/util/unique_ptr.h"
+
+#include <cinttypes>
+#include <optional>
+
+using ::chre::message::Endpoint;
+using ::chre::message::EndpointId;
+using ::chre::message::EndpointInfo;
+using ::chre::message::EndpointType;
+using ::chre::message::Message;
+using ::chre::message::MessageRouter;
+using ::chre::message::MessageRouterSingleton;
+using ::chre::message::Session;
+
+namespace chre {
+
+void ChreMessageHubManager::init() {
+ std::optional<MessageRouter::MessageHub> chreMessageHub =
+ MessageRouterSingleton::get()->registerMessageHub(
+ "CHRE", kChreMessageHubId, *this);
+ if (chreMessageHub.has_value()) {
+ mChreMessageHub = std::move(*chreMessageHub);
+ } else {
+ LOGE("Failed to register the CHRE MessageHub");
+ }
+}
+
+void ChreMessageHubManager::onMessageToNanoappCallback(
+ SystemCallbackType /* type */, UniquePtr<MessageCallbackData> &&data) {
+ bool success = false;
+ Nanoapp *nanoapp =
+ EventLoopManagerSingleton::get()->getEventLoop().findNanoappByAppId(
+ data->nanoappId);
+ uint32_t messagePermissions = data->messageToNanoapp.messagePermissions;
+ if (nanoapp == nullptr) {
+ LOGE("Unable to find nanoapp with ID 0x%" PRIx64
+ " to receive message with type %" PRIu32 " and permissions %" PRIu32
+ " with session ID %" PRIu16,
+ data->nanoappId, data->messageToNanoapp.messageType,
+ data->messageToNanoapp.messagePermissions,
+ data->messageToNanoapp.sessionId);
+ } else if (!nanoapp->hasPermissions(messagePermissions)) {
+ LOGE("nanoapp with ID 0x%" PRIx64
+ " does not have permissions to receive "
+ "message with type %" PRIu32 " and permissions 0x%" PRIx32,
+ nanoapp->getAppId(), data->messageToNanoapp.messageType,
+ data->messageToNanoapp.messagePermissions);
+ } else if (!EventLoopManagerSingleton::get()
+ ->getEventLoop()
+ .distributeEventSync(CHRE_EVENT_MESSAGE_FROM_ENDPOINT,
+ &data->messageToNanoapp,
+ nanoapp->getInstanceId())) {
+ LOGE("Unable to distribute message to nanoapp with ID 0x%" PRIx64,
+ nanoapp->getAppId());
+ } else {
+ success = true;
+ }
+
+ // Close session on failure so sender knows there was an issue
+ if (!success) {
+ EventLoopManagerSingleton::get()
+ ->getChreMessageHubManager()
+ .getMessageHub()
+ .closeSession(data->messageToNanoapp.sessionId);
+ }
+}
+
+void ChreMessageHubManager::onSessionClosedCallback(
+ SystemCallbackType /* type */,
+ UniquePtr<SessionClosedCallbackData> &&data) {
+ Nanoapp *nanoapp =
+ EventLoopManagerSingleton::get()->getEventLoop().findNanoappByAppId(
+ data->nanoappId);
+ if (nanoapp == nullptr) {
+ LOGE("Unable to find nanoapp with ID 0x%" PRIx64
+ " to close the session with ID %" PRIu16,
+ data->nanoappId, data->sessionClosedData.sessionId);
+ return;
+ }
+
+ bool success =
+ EventLoopManagerSingleton::get()->getEventLoop().distributeEventSync(
+ CHRE_EVENT_ENDPOINT_SESSION_CLOSED, &data->sessionClosedData,
+ nanoapp->getInstanceId());
+ if (!success) {
+ LOGE("Unable to process session closed event to nanoapp with ID 0x%" PRIx64,
+ nanoapp->getAppId());
+ }
+}
+
+bool ChreMessageHubManager::onMessageReceived(pw::UniquePtr<std::byte[]> &&data,
+ size_t length,
+ uint32_t messageType,
+ uint32_t messagePermissions,
+ const Session &session,
+ bool sentBySessionInitiator) {
+ Endpoint receiver = sentBySessionInitiator ? session.peer : session.initiator;
+ auto messageCallbackData = MakeUnique<MessageCallbackData>();
+ if (messageCallbackData.isNull()) {
+ LOG_OOM();
+ return false;
+ }
+
+ messageCallbackData->messageToNanoapp = {
+ .messageType = messageType,
+ .messagePermissions = messagePermissions,
+ .message = data.get(),
+ .messageSize = length,
+ .sessionId = session.sessionId,
+ };
+ messageCallbackData->data = std::move(data);
+ messageCallbackData->nanoappId = receiver.endpointId;
+
+ EventLoopManagerSingleton::get()->deferCallback(
+ SystemCallbackType::EndpointMessageToNanoappEvent,
+ std::move(messageCallbackData),
+ ChreMessageHubManager::onMessageToNanoappCallback);
+ return true;
+}
+
+void ChreMessageHubManager::onSessionClosed(const Session &session) {
+ auto sessionClosedCallbackData = MakeUnique<SessionClosedCallbackData>();
+ if (sessionClosedCallbackData.isNull()) {
+ LOG_OOM();
+ return;
+ }
+
+ Endpoint otherParty;
+ uint64_t nanoappId;
+ if (session.initiator.messageHubId == kChreMessageHubId) {
+ otherParty = session.peer;
+ nanoappId = session.initiator.endpointId;
+ } else {
+ otherParty = session.initiator;
+ nanoappId = session.peer.endpointId;
+ }
+
+ sessionClosedCallbackData->sessionClosedData = {
+ .hubId = otherParty.messageHubId,
+ .endpointId = otherParty.endpointId,
+ .sessionId = session.sessionId,
+ };
+ sessionClosedCallbackData->nanoappId = nanoappId;
+
+ EventLoopManagerSingleton::get()->deferCallback(
+ SystemCallbackType::EndpointSessionClosedEvent,
+ std::move(sessionClosedCallbackData),
+ ChreMessageHubManager::onSessionClosedCallback);
+}
+
+void ChreMessageHubManager::forEachEndpoint(
+ const pw::Function<bool(const EndpointInfo &)> &function) {
+ EventLoopManagerSingleton::get()->getEventLoop().onMatchingNanoappEndpoint(
+ function);
+}
+
+std::optional<EndpointInfo> ChreMessageHubManager::getEndpointInfo(
+ EndpointId endpointId) {
+ return EventLoopManagerSingleton::get()->getEventLoop().getEndpointInfo(
+ endpointId);
+}
+
+} // namespace chre
+
+#endif // CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
diff --git a/core/core.mk b/core/core.mk
index 02aa3ec..d931458 100644
--- a/core/core.mk
+++ b/core/core.mk
@@ -9,6 +9,7 @@
# Common Source Files ##########################################################
+COMMON_SRCS += $(CHRE_PREFIX)/core/chre_message_hub_manager.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/debug_dump_manager.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/event.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/event_loop.cc
@@ -17,7 +18,6 @@
COMMON_SRCS += $(CHRE_PREFIX)/core/host_comms_manager.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/host_endpoint_manager.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/init.cc
-COMMON_SRCS += $(CHRE_PREFIX)/core/log.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/nanoapp.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/settings.cc
COMMON_SRCS += $(CHRE_PREFIX)/core/static_nanoapps.cc
diff --git a/core/event_loop.cc b/core/event_loop.cc
index 7c304c9..d5063e8 100644
--- a/core/event_loop.cc
+++ b/core/event_loop.cc
@@ -24,6 +24,7 @@
#include "chre/core/nanoapp.h"
#include "chre/platform/assert.h"
#include "chre/platform/context.h"
+#include "chre/platform/event_loop_hooks.h"
#include "chre/platform/fatal_error.h"
#include "chre/platform/system_time.h"
#include "chre/util/conditional_lock_guard.h"
@@ -35,6 +36,9 @@
#include "chre/util/time.h"
#include "chre_api/chre/version.h"
+using ::chre::message::EndpointInfo;
+using ::chre::message::EndpointType;
+
namespace chre {
// Out of line declaration required for nonintegral static types
@@ -301,25 +305,16 @@
targetLowPriorityEventRemove);
}
-bool EventLoop::deliverEventSync(uint16_t nanoappInstanceId,
- uint16_t eventType,
- void *eventData) {
+bool EventLoop::distributeEventSync(uint16_t eventType, void *eventData,
+ uint16_t targetInstanceId,
+ uint16_t targetGroupMask) {
CHRE_ASSERT(inEventLoopThread());
-
Event event(eventType, eventData,
/* freeCallback= */ nullptr,
/* isLowPriority= */ false,
- /* senderInstanceId= */ kSystemInstanceId,
- /* targetInstanceId= */ nanoappInstanceId,
- kDefaultTargetGroupMask);
- for (const UniquePtr<Nanoapp> &app : mNanoapps) {
- if (app->getInstanceId() == nanoappInstanceId) {
- deliverNextEvent(app, &event);
- return true;
- }
- }
-
- return false;
+ /* senderInstanceId= */ kSystemInstanceId, targetInstanceId,
+ targetGroupMask);
+ return distributeEventCommon(&event);
}
// TODO(b/264108686): Refactor this function and postSystemEvent
@@ -332,6 +327,9 @@
!allocateAndPostEvent(eventType, eventData, freeCallback,
/* isLowPriority= */ false, kSystemInstanceId,
targetInstanceId, targetGroupMask)) {
+ CHRE_HANDLE_FAILED_SYSTEM_EVENT_ENQUEUE(
+ this, eventType, eventData, freeCallback, kSystemInstanceId,
+ targetInstanceId, targetGroupMask);
FATAL_ERROR("Failed to post critical system event 0x%" PRIx16, eventType);
}
} else if (freeCallback != nullptr) {
@@ -347,6 +345,8 @@
}
if (hasNoSpaceForHighPriorityEvent()) {
+ CHRE_HANDLE_EVENT_QUEUE_FULL_DURING_SYSTEM_POST(this, eventType, eventData,
+ callback, extraData);
FATAL_ERROR("Failed to post critical system event 0x%" PRIx16
": Full of high priority "
"events",
@@ -355,6 +355,9 @@
Event *event = mEventPool.allocate(eventType, eventData, callback, extraData);
if (event == nullptr || !mEvents.push(event)) {
+ CHRE_HANDLE_FAILED_SYSTEM_EVENT_ENQUEUE(
+ this, eventType, eventData, callback, kSystemInstanceId,
+ kBroadcastInstanceId, kDefaultTargetGroupMask);
FATAL_ERROR("Failed to post critical system event 0x%" PRIx16
": out of memory",
eventType);
@@ -377,6 +380,9 @@
if (!eventPosted) {
LOGE("Failed to allocate event 0x%" PRIx16 " to instanceId %" PRIu16,
eventType, targetInstanceId);
+ CHRE_HANDLE_LOW_PRIORITY_ENQUEUE_FAILURE(
+ this, eventType, eventData, freeCallback, senderInstanceId,
+ targetInstanceId, targetGroupMask);
++mNumDroppedLowPriEvents;
}
}
@@ -408,6 +414,11 @@
return lookupAppByInstanceId(instanceId);
}
+Nanoapp *EventLoop::findNanoappByAppId(uint64_t appId) const {
+ ConditionalLockGuard<Mutex> lock(mNanoappsLock, !inEventLoopThread());
+ return lookupAppByAppId(appId);
+}
+
bool EventLoop::populateNanoappInfoForAppId(
uint64_t appId, struct chreNanoappInfo *info) const {
ConditionalLockGuard<Mutex> lock(mNanoappsLock, !inEventLoopThread());
@@ -462,6 +473,25 @@
}
}
+void EventLoop::onMatchingNanoappEndpoint(
+ const pw::Function<bool(const EndpointInfo &)> &function) {
+ ConditionalLockGuard<Mutex> lock(mNanoappsLock, !inEventLoopThread());
+
+ for (const UniquePtr<Nanoapp> &app : mNanoapps) {
+ if (function(getEndpointInfoFromNanoappLocked(*app.get()))) {
+ break;
+ }
+ }
+}
+
+std::optional<EndpointInfo> EventLoop::getEndpointInfo(uint64_t appId) {
+ ConditionalLockGuard<Mutex> lock(mNanoappsLock, !inEventLoopThread());
+ Nanoapp *app = lookupAppByAppId(appId);
+ return app == nullptr
+ ? std::nullopt
+ : std::make_optional(getEndpointInfoFromNanoappLocked(*app));
+}
+
bool EventLoop::allocateAndPostEvent(uint16_t eventType, void *eventData,
chreEventCompleteFunction *freeCallback,
bool isLowPriority,
@@ -514,13 +544,27 @@
}
void EventLoop::distributeEvent(Event *event) {
+ distributeEventCommon(event);
+ CHRE_ASSERT(event->isUnreferenced());
+ freeEvent(event);
+}
+
+bool EventLoop::distributeEventCommon(Event *event) {
bool eventDelivered = false;
- for (const UniquePtr<Nanoapp> &app : mNanoapps) {
- if ((event->targetInstanceId == chre::kBroadcastInstanceId &&
- app->isRegisteredForBroadcastEvent(event)) ||
- event->targetInstanceId == app->getInstanceId()) {
- eventDelivered = true;
- deliverNextEvent(app, event);
+ if (event->targetInstanceId == kBroadcastInstanceId) {
+ for (const UniquePtr<Nanoapp> &app : mNanoapps) {
+ if (app->isRegisteredForBroadcastEvent(event)) {
+ eventDelivered = true;
+ deliverNextEvent(app, event);
+ }
+ }
+ } else {
+ for (const UniquePtr<Nanoapp> &app : mNanoapps) {
+ if (event->targetInstanceId == app->getInstanceId()) {
+ eventDelivered = true;
+ deliverNextEvent(app, event);
+ break;
+ }
}
}
// Log if an event unicast to a nanoapp isn't delivered, as this is could be
@@ -533,8 +577,7 @@
LOGW("Dropping event 0x%" PRIx16 " from instanceId %" PRIu16 "->%" PRIu16,
event->eventType, event->senderInstanceId, event->targetInstanceId);
}
- CHRE_ASSERT(event->isUnreferenced());
- freeEvent(event);
+ return eventDelivered;
}
void EventLoop::flushInboundEventQueue() {
@@ -681,4 +724,14 @@
}
}
+EndpointInfo EventLoop::getEndpointInfoFromNanoappLocked(
+ const Nanoapp &nanoapp) {
+ return EndpointInfo(
+ /* id= */ nanoapp.getAppId(),
+ /* name= */ nanoapp.getAppName(),
+ /* version= */ nanoapp.getAppVersion(),
+ /* type= */ EndpointType::NANOAPP,
+ /* requiredPermissions= */ nanoapp.getAppPermissions());
+}
+
} // namespace chre
diff --git a/core/event_loop_manager.cc b/core/event_loop_manager.cc
index 4baf5d6..e802135 100644
--- a/core/event_loop_manager.cc
+++ b/core/event_loop_manager.cc
@@ -16,6 +16,8 @@
#include "chre/core/event_loop_manager.h"
+#include "chre/core/event_loop_common.h"
+#include "chre/event.h"
#include "chre/platform/atomic.h"
#include "chre/platform/fatal_error.h"
#include "chre/platform/memory.h"
@@ -71,6 +73,10 @@
#ifdef CHRE_BLE_SUPPORT_ENABLED
mBleRequestManager.init();
#endif // CHRE_BLE_SUPPORT_ENABLED
+
+#ifdef CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+ mChreMessageHubManager.init();
+#endif // CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
}
// Explicitly instantiate the EventLoopManagerSingleton to reduce codesize.
diff --git a/core/gnss_manager.cc b/core/gnss_manager.cc
index 4fce1ef..e11e9b1 100644
--- a/core/gnss_manager.cc
+++ b/core/gnss_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_GNSS_SUPPORT_ENABLED
+
#include "chre/core/gnss_manager.h"
#include <cstddef>
@@ -768,3 +770,5 @@
}
} // namespace chre
+
+#endif // CHRE_GNSS_SUPPORT_ENABLED
diff --git a/core/host_comms_manager.cc b/core/host_comms_manager.cc
index b00a8c5..1dc6b79 100644
--- a/core/host_comms_manager.cc
+++ b/core/host_comms_manager.cc
@@ -27,7 +27,6 @@
#include "chre/platform/context.h"
#include "chre/platform/host_link.h"
#include "chre/platform/log.h"
-#include "chre/target_platform/log.h"
#include "chre/util/duplicate_message_detector.h"
#include "chre/util/macros.h"
#include "chre/util/nested_data_ptr.h"
@@ -352,9 +351,9 @@
if (!foundNanoapp) {
error = CHRE_ERROR_DESTINATION_NOT_FOUND;
} else if (shouldDeliverMessage) {
- EventLoopManagerSingleton::get()->getEventLoop().deliverEventSync(
- targetInstanceId, CHRE_EVENT_MESSAGE_FROM_HOST,
- &craftedMessage->fromHostData);
+ EventLoopManagerSingleton::get()->getEventLoop().distributeEventSync(
+ CHRE_EVENT_MESSAGE_FROM_HOST, &craftedMessage->fromHostData,
+ targetInstanceId);
error = CHRE_ERROR_NONE;
}
@@ -485,8 +484,8 @@
asyncResult.cookie = message->cookie;
onMessageToHostCompleteInternal(message);
- eventLoop.deliverEventSync(
- nanoappInstanceId, CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT, &asyncResult);
+ eventLoop.distributeEventSync(CHRE_EVENT_RELIABLE_MSG_ASYNC_RESULT,
+ &asyncResult, nanoappInstanceId);
}
}
diff --git a/core/host_endpoint_manager.cc b/core/host_endpoint_manager.cc
index 694be90..3e776e8 100644
--- a/core/host_endpoint_manager.cc
+++ b/core/host_endpoint_manager.cc
@@ -88,12 +88,11 @@
bool HostEndpointManager::getHostEndpointInfo(
uint16_t hostEndpointId, struct chreHostEndpointInfo *info) {
size_t index;
- if (isHostEndpointConnected(hostEndpointId, &index)) {
+ bool isConnected = isHostEndpointConnected(hostEndpointId, &index);
+ if (isConnected) {
*info = mHostEndpoints[index];
- return true;
- } else {
- return false;
}
+ return isConnected;
}
void HostEndpointManager::postHostEndpointConnected(
diff --git a/core/include/chre/core/audio_request_manager.h b/core/include/chre/core/audio_request_manager.h
index 8b97a34..a35b54b 100644
--- a/core/include/chre/core/audio_request_manager.h
+++ b/core/include/chre/core/audio_request_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_AUDIO_REQUEST_MANAGER_H_
#define CHRE_CORE_AUDIO_REQUEST_MANAGER_H_
+#ifdef CHRE_AUDIO_SUPPORT_ENABLED
+
#include <cstdint>
#include "chre/core/nanoapp.h"
@@ -383,4 +385,6 @@
} // namespace chre
+#endif // CHRE_AUDIO_SUPPORT_ENABLED
+
#endif // CHRE_CORE_AUDIO_REQUEST_MANAGER_H_
diff --git a/core/include/chre/core/ble_request_manager.h b/core/include/chre/core/ble_request_manager.h
index 957b8ab..847994d 100644
--- a/core/include/chre/core/ble_request_manager.h
+++ b/core/include/chre/core/ble_request_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_BLE_REQUEST_MANAGER_H_
#define CHRE_CORE_BLE_REQUEST_MANAGER_H_
+#ifdef CHRE_BLE_SUPPORT_ENABLED
+
#include "chre/core/ble_request.h"
#include "chre/core/ble_request_multiplexer.h"
#include "chre/core/nanoapp.h"
@@ -582,4 +584,6 @@
} // namespace chre
+#endif // CHRE_BLE_SUPPORT_ENABLED
+
#endif // CHRE_CORE_BLE_REQUEST_MANAGER_H_
diff --git a/core/include/chre/core/chre_message_hub_manager.h b/core/include/chre/core/chre_message_hub_manager.h
new file mode 100644
index 0000000..15aaea9
--- /dev/null
+++ b/core/include/chre/core/chre_message_hub_manager.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_CORE_CHRE_MESSAGE_HUB_MANAGER_H_
+#define CHRE_CORE_CHRE_MESSAGE_HUB_MANAGER_H_
+
+#ifdef CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+
+#include "chre/core/event_loop_common.h"
+#include "chre/util/non_copyable.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router.h"
+#include "chre/util/unique_ptr.h"
+
+#include <cinttypes>
+#include <optional>
+
+namespace chre {
+
+//! Manager class for the CHRE Message Hub.
+class ChreMessageHubManager
+ : public NonCopyable,
+ public message::MessageRouter::MessageHubCallback {
+ public:
+ //! The ID of the CHRE MessageHub
+ constexpr static message::MessageHubId kChreMessageHubId = CHRE_PLATFORM_ID;
+
+ //! Initializes the ChreMessageHubManager
+ void init();
+
+ //! Returns the MessageHub for the CHRE Message Hub
+ message::MessageRouter::MessageHub &getMessageHub() {
+ return mChreMessageHub;
+ }
+
+ private:
+ //! Data to be passed to the message callback
+ struct MessageCallbackData {
+ chreMessageFromEndpointData messageToNanoapp;
+ pw::UniquePtr<std::byte[]> data;
+ uint64_t nanoappId;
+ };
+
+ //! Data to be passed to the session closed callback
+ struct SessionClosedCallbackData {
+ chreEndpointSessionClosedData sessionClosedData;
+ uint64_t nanoappId;
+ };
+
+ //! Callback to process message sent to a nanoapp - used by the event loop
+ static void onMessageToNanoappCallback(
+ SystemCallbackType /* type */,
+ UniquePtr<ChreMessageHubManager::MessageCallbackData> &&data);
+
+ //! Callback to process session closed event for a nanoapp - used by the event
+ //! loop
+ static void onSessionClosedCallback(
+ SystemCallbackType /* type */,
+ UniquePtr<ChreMessageHubManager::SessionClosedCallbackData> &&data);
+
+ //! Definitions for MessageHubCallback
+ //! @see MessageRouter::MessageHubCallback
+ bool onMessageReceived(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions,
+ const message::Session &session,
+ bool sentBySessionInitiator) override;
+ void onSessionClosed(const message::Session &session) override;
+ void forEachEndpoint(const pw::Function<bool(const message::EndpointInfo &)>
+ &function) override;
+ std::optional<message::EndpointInfo> getEndpointInfo(
+ message::EndpointId endpointId) override;
+
+ message::MessageRouter::MessageHub mChreMessageHub;
+};
+
+} // namespace chre
+
+#endif // CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+
+#endif // CHRE_CORE_CHRE_MESSAGE_HUB_MANAGER_H_
diff --git a/core/include/chre/core/event_loop.h b/core/include/chre/core/event_loop.h
index fe7993a..97e11e5 100644
--- a/core/include/chre/core/event_loop.h
+++ b/core/include/chre/core/event_loop.h
@@ -17,6 +17,10 @@
#ifndef CHRE_CORE_EVENT_LOOP_H_
#define CHRE_CORE_EVENT_LOOP_H_
+#include <pw_function/function.h>
+#include <stddef.h>
+#include <optional>
+
#include "chre/core/event.h"
#include "chre/core/nanoapp.h"
#include "chre/core/timer_pool.h"
@@ -27,13 +31,14 @@
#include "chre/util/dynamic_vector.h"
#include "chre/util/non_copyable.h"
#include "chre/util/system/debug_dump.h"
+#include "chre/util/system/message_common.h"
#include "chre/util/system/stats_container.h"
#include "chre/util/unique_ptr.h"
#include "chre_api/chre/event.h"
#ifdef CHRE_STATIC_EVENT_LOOP
-#include "chre/util/fixed_size_blocking_queue.h"
-#include "chre/util/synchronized_memory_pool.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
+#include "chre/util/system/synchronized_memory_pool.h"
// These default values can be overridden in the variant-specific makefile.
#ifndef CHRE_MAX_EVENT_COUNT
@@ -45,7 +50,7 @@
#endif
#else
#include "chre/util/blocking_segmented_queue.h"
-#include "chre/util/synchronized_expandable_memory_pool.h"
+#include "chre/util/system/synchronized_expandable_memory_pool.h"
// These default values can be overridden in the variant-specific makefile.
#ifndef CHRE_EVENT_PER_BLOCK
@@ -67,6 +72,11 @@
*/
class EventLoop : public NonCopyable {
public:
+ /**
+ * Synchronous callback used with forEachNanoapp
+ */
+ typedef void(NanoappCallbackFunction)(const Nanoapp *nanoapp, void *data);
+
EventLoop()
:
#ifndef CHRE_STATIC_EVENT_LOOP
@@ -77,11 +87,6 @@
}
/**
- * Synchronous callback used with forEachNanoapp
- */
- typedef void(NanoappCallbackFunction)(const Nanoapp *nanoapp, void *data);
-
- /**
* Searches the set of nanoapps managed by this EventLoop for one with the
* given app ID. If found, provides its instance ID, which can be used to send
* events to the app.
@@ -172,8 +177,15 @@
void stop();
/**
- * Synchronously deliver an event to a nanoapp. The event is sent from the
- * system to the nanoapp with instance ID nanoappInstanceId.
+ * Synchronously distributes an event to all nanoapps that should receive it.
+ * The event is sent from the system to a specific nanoapp if targetInstanceId
+ * matches the nanoappId, or to all registered nanoapps if targetInstanceId
+ * is set to kBroadcastInstanceId
+ *
+ * This is intended to be used by the function provided to
+ * EventLoopManager::deferCallback in cases where pre- and post-processing are
+ * required around event delivery. This closes the gaps around event delivery
+ * and can remove the need for posting multiple events.
*
* This must only be used from the EventLoop thread, and must only be used in
* rare circumstances where one of the postEvent functions cannot be used. In
@@ -181,16 +193,18 @@
* ordering guarantees and trigger subtle bugs in nanoapps, so use with
* caution.
*
- * freeCallback is guaranteed to be called before returning.
+ * No freeCallback is provided. The caller is expected to manage the memory
+ * for eventData, and handle any cleanup.
*
- * @param nanoappInstanceId The instance ID of the destination of this event
* @param eventType Event type identifier, which implies the type of eventData
* @param eventData The data being posted
- * @return true if the event was successfully delivered, false otherwise.
+ * @param targetInstanceId The instance ID of the destination of this event
+ * @param targetGroupMask Mask used to limit the recipients that are
+ * registered to receive this event
*/
- bool deliverEventSync(uint16_t nanoappInstanceId,
- uint16_t eventType,
- void *eventData);
+ bool distributeEventSync(uint16_t eventType, void *eventData,
+ uint16_t targetInstanceId = kBroadcastInstanceId,
+ uint16_t targetGroupMask = kDefaultTargetGroupMask);
/**
* Posts an event to a nanoapp that is currently running (or all nanoapps if
@@ -314,6 +328,17 @@
Nanoapp *findNanoappByInstanceId(uint16_t instanceId) const;
/**
+ * Searches the set of nanoapps managed by this EventLoop for one with the
+ * given nanoapp ID.
+ *
+ * This function is safe to call from any thread.
+ *
+ * @param appId The nanoapp ID to search for.
+ * @return a pointer to the found nanoapp or nullptr if no match was found.
+ */
+ Nanoapp *findNanoappByAppId(uint64_t appId) const;
+
+ /**
* Looks for an app with the given ID and if found, populates info with its
* metadata. Safe to call from any thread.
*
@@ -347,6 +372,28 @@
void logStateToBuffer(DebugDumpWrapper &debugDump) const;
/**
+ * Executes function for each nanoapp in the event loop. If function
+ * returns true, the iteration will stop.
+ *
+ * This function is safe to call from any thread.
+ *
+ * @param function The function to execute for each nanoapp.
+ */
+ void onMatchingNanoappEndpoint(
+ const pw::Function<bool(const message::EndpointInfo &)> &function);
+
+ /**
+ * Returns the EndpointInfo for the given nanoapp.
+ *
+ * This function is safe to call from any thread.
+ *
+ * @param appId The nanoapp ID to search for.
+ * @return The EndpointInfo for the given nanoapp, or std::nullopt if not
+ * found.
+ */
+ std::optional<message::EndpointInfo> getEndpointInfo(uint64_t appId);
+
+ /**
* Returns a reference to the power control manager. This allows power
* controls from subsystems outside the event loops.
*/
@@ -489,6 +536,16 @@
void distributeEvent(Event *event);
/**
+ * Shared functionality to distributeEvent and distributeEventSync. Should
+ * only be called by those functions. Hnadles event distribution and logging
+ * without any pre- or post-processing.
+ *
+ * @param event The Event to distribute to Nanoapps
+ * @return True if the event was delivered to any nanoapps, otherwise false
+ */
+ bool distributeEventCommon(Event *event);
+
+ /**
* Distribute all events pending in the inbound event queue. Note that this
* function only guarantees that any events in the inbound queue at the time
* it is called will be distributed to Nanoapp event queues - new events may
@@ -559,6 +616,18 @@
* @param count The number of dangling resources.
*/
void logDanglingResources(const char *name, uint32_t count);
+
+ /**
+ * Returns the EndpointInfo for the given nanoapp.
+ *
+ * Only safe to call within this EventLoop's thread, or if mNanoappsLock is
+ * held.
+ *
+ * @param nanoapp The nanoapp to get the EndpointInfo for.
+ * @return The EndpointInfo for the given nanoapp
+ */
+ message::EndpointInfo getEndpointInfoFromNanoappLocked(
+ const Nanoapp &nanoapp);
};
} // namespace chre
diff --git a/core/include/chre/core/event_loop_common.h b/core/include/chre/core/event_loop_common.h
index ca280d1..ea2203d 100644
--- a/core/include/chre/core/event_loop_common.h
+++ b/core/include/chre/core/event_loop_common.h
@@ -76,6 +76,8 @@
ReliableMessageEvent,
TimerPoolTimerExpired,
TransactionManagerTimeout,
+ EndpointMessageToNanoappEvent,
+ EndpointSessionClosedEvent,
};
//! Deferred/delayed callbacks use the event subsystem but are invariably sent
diff --git a/core/include/chre/core/event_loop_manager.h b/core/include/chre/core/event_loop_manager.h
index b5f52b3..255f9ee 100644
--- a/core/include/chre/core/event_loop_manager.h
+++ b/core/include/chre/core/event_loop_manager.h
@@ -17,13 +17,21 @@
#ifndef CHRE_CORE_EVENT_LOOP_MANAGER_H_
#define CHRE_CORE_EVENT_LOOP_MANAGER_H_
+#include "chre/core/audio_request_manager.h"
+#include "chre/core/ble_request_manager.h"
+#include "chre/core/chre_message_hub_manager.h"
#include "chre/core/debug_dump_manager.h"
#include "chre/core/event_loop.h"
#include "chre/core/event_loop_common.h"
+#include "chre/core/gnss_manager.h"
#include "chre/core/host_comms_manager.h"
#include "chre/core/host_endpoint_manager.h"
+#include "chre/core/sensor_request_manager.h"
#include "chre/core/settings.h"
#include "chre/core/system_health_monitor.h"
+#include "chre/core/telemetry_manager.h"
+#include "chre/core/wifi_request_manager.h"
+#include "chre/core/wwan_request_manager.h"
#include "chre/platform/atomic.h"
#include "chre/platform/memory_manager.h"
#include "chre/platform/mutex.h"
@@ -34,34 +42,6 @@
#include "chre/util/unique_ptr.h"
#include "chre_api/chre/event.h"
-#ifdef CHRE_AUDIO_SUPPORT_ENABLED
-#include "chre/core/audio_request_manager.h"
-#endif // CHRE_AUDIO_SUPPORT_ENABLED
-
-#ifdef CHRE_BLE_SUPPORT_ENABLED
-#include "chre/core/ble_request_manager.h"
-#endif // CHRE_BLE_SUPPORT_ENABLED
-
-#ifdef CHRE_GNSS_SUPPORT_ENABLED
-#include "chre/core/gnss_manager.h"
-#endif // CHRE_GNSS_SUPPORT_ENABLED
-
-#ifdef CHRE_SENSORS_SUPPORT_ENABLED
-#include "chre/core/sensor_request_manager.h"
-#endif // CHRE_SENSORS_SUPPORT_ENABLED
-
-#ifdef CHRE_WIFI_SUPPORT_ENABLED
-#include "chre/core/wifi_request_manager.h"
-#endif // CHRE_WIFI_SUPPORT_ENABLED
-
-#ifdef CHRE_WWAN_SUPPORT_ENABLED
-#include "chre/core/wwan_request_manager.h"
-#endif // CHRE_WWAN_SUPPORT_ENABLED
-
-#ifdef CHRE_TELEMETRY_SUPPORT_ENABLED
-#include "chre/core/telemetry_manager.h"
-#endif // CHRE_TELEMETRY_SUPPORT_ENABLED
-
#include <cstddef>
namespace chre {
@@ -342,6 +322,12 @@
return mSystemHealthMonitor;
}
+#ifdef CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+ ChreMessageHubManager &getChreMessageHubManager() {
+ return mChreMessageHubManager;
+ }
+#endif // CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+
/**
* Performs second-stage initialization of things that are not necessarily
* required at construction time but need to be completed prior to executing
@@ -413,6 +399,11 @@
//! The SettingManager that manages setting states.
SettingManager mSettingManager;
+
+#ifdef CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
+ //! The ChreMessageHubManager that manages the CHRE Message Hub.
+ ChreMessageHubManager mChreMessageHubManager;
+#endif // CHRE_MESSAGE_ROUTER_SUPPORT_ENABLED
};
//! Provide an alias to the EventLoopManager singleton.
diff --git a/core/include/chre/core/gnss_manager.h b/core/include/chre/core/gnss_manager.h
index d4885ff..ed595d9 100644
--- a/core/include/chre/core/gnss_manager.h
+++ b/core/include/chre/core/gnss_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_GNSS_MANAGER_H_
#define CHRE_CORE_GNSS_MANAGER_H_
+#ifdef CHRE_GNSS_SUPPORT_ENABLED
+
#include <cstdint>
#include "chre/core/api_manager_common.h"
@@ -511,4 +513,6 @@
} // namespace chre
+#endif // CHRE_GNSS_SUPPORT_ENABLED
+
#endif // CHRE_CORE_GNSS_MANAGER_H_
diff --git a/core/include/chre/core/host_comms_manager.h b/core/include/chre/core/host_comms_manager.h
index a32a09a..305c19e 100644
--- a/core/include/chre/core/host_comms_manager.h
+++ b/core/include/chre/core/host_comms_manager.h
@@ -27,9 +27,9 @@
#include "chre/util/buffer.h"
#include "chre/util/duplicate_message_detector.h"
#include "chre/util/non_copyable.h"
-#include "chre/util/synchronized_memory_pool.h"
+#include "chre/util/system/synchronized_memory_pool.h"
+#include "chre/util/system/transaction_manager.h"
#include "chre/util/time.h"
-#include "chre/util/transaction_manager.h"
#include "chre_api/chre/event.h"
namespace chre {
diff --git a/core/include/chre/core/nanoapp.h b/core/include/chre/core/nanoapp.h
index 9fb9a98..68404d2 100644
--- a/core/include/chre/core/nanoapp.h
+++ b/core/include/chre/core/nanoapp.h
@@ -302,6 +302,15 @@
return mFirstHeader;
}
+ /**
+ * @return whether the nanoapp has the provided permissions.
+ */
+ bool hasPermissions(uint32_t permissions) const {
+ return permissions == 0 ||
+ (supportsAppPermissions() &&
+ (getAppPermissions() & permissions) == permissions);
+ }
+
private:
uint16_t mInstanceId = kInvalidInstanceId;
diff --git a/core/include/chre/core/sensor_request_manager.h b/core/include/chre/core/sensor_request_manager.h
index b91c154..5509d94 100644
--- a/core/include/chre/core/sensor_request_manager.h
+++ b/core/include/chre/core/sensor_request_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_SENSOR_REQUEST_MANAGER_H_
#define CHRE_CORE_SENSOR_REQUEST_MANAGER_H_
+#ifdef CHRE_SENSORS_SUPPORT_ENABLED
+
#include "chre/core/sensor.h"
#include "chre/core/sensor_request.h"
#include "chre/core/sensor_request_multiplexer.h"
@@ -515,4 +517,6 @@
} // namespace chre
+#endif // CHRE_SENSORS_SUPPORT_ENABLED
+
#endif // CHRE_CORE_SENSOR_REQUEST_MANAGER_H_
diff --git a/core/include/chre/core/telemetry_manager.h b/core/include/chre/core/telemetry_manager.h
index 9364f86..768b654 100644
--- a/core/include/chre/core/telemetry_manager.h
+++ b/core/include/chre/core/telemetry_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_TELEMETRY_MANAGER_H_
#define CHRE_CORE_TELEMETRY_MANAGER_H_
+#ifdef CHRE_TELEMETRY_SUPPORT_ENABLED
+
#include <cinttypes>
#include "chre/util/non_copyable.h"
@@ -64,4 +66,6 @@
} // namespace chre
+#endif // CHRE_TELEMETRY_SUPPORT_ENABLED
+
#endif // CHRE_CORE_TELEMETRY_MANAGER_H_
diff --git a/core/include/chre/core/wifi_request_manager.h b/core/include/chre/core/wifi_request_manager.h
index b5e2708..46837d6 100644
--- a/core/include/chre/core/wifi_request_manager.h
+++ b/core/include/chre/core/wifi_request_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_WIFI_REQUEST_MANAGER_H_
#define CHRE_CORE_WIFI_REQUEST_MANAGER_H_
+#ifdef CHRE_WIFI_SUPPORT_ENABLED
+
#include "chre/core/api_manager_common.h"
#include "chre/core/nanoapp.h"
#include "chre/core/settings.h"
@@ -922,4 +924,6 @@
} // namespace chre
+#endif // CHRE_WIFI_SUPPORT_ENABLED
+
#endif // CHRE_CORE_WIFI_REQUEST_MANAGER_H_
diff --git a/core/include/chre/core/wwan_request_manager.h b/core/include/chre/core/wwan_request_manager.h
index 1c1e278..9b8b1ef 100644
--- a/core/include/chre/core/wwan_request_manager.h
+++ b/core/include/chre/core/wwan_request_manager.h
@@ -17,6 +17,8 @@
#ifndef CHRE_CORE_WWAN_REQUEST_MANAGER_H_
#define CHRE_CORE_WWAN_REQUEST_MANAGER_H_
+#ifdef CHRE_WWAN_SUPPORT_ENABLED
+
#include <cstdint>
#include "chre/core/api_manager_common.h"
@@ -121,4 +123,6 @@
} // namespace chre
+#endif // CHRE_WWAN_SUPPORT_ENABLED
+
#endif // CHRE_CORE_WWAN_REQUEST_MANAGER_H_
diff --git a/core/log.cc b/core/log.cc
deleted file mode 100644
index f95b888..0000000
--- a/core/log.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifdef CHRE_TOKENIZED_LOGGING_ENABLED
-#include "chre/platform/log.h"
-#include "pw_log_tokenized/config.h"
-#include "pw_tokenizer/encode_args.h"
-#include "pw_tokenizer/tokenize.h"
-
-// The callback function that must be defined to handle an encoded
-// tokenizer message.
-
-void EncodeTokenizedMessage(uint32_t level, pw_tokenizer_Token token,
- pw_tokenizer_ArgTypes types, ...) {
- va_list args;
- va_start(args, types);
- pw::tokenizer::EncodedMessage<pw::log_tokenized::kEncodingBufferSizeBytes>
- encodedMessage(token, types, args);
- va_end(args);
-
- chrePlatformEncodedLogToBuffer(static_cast<chreLogLevel>(level),
- encodedMessage.data_as_uint8(),
- encodedMessage.size());
-}
-
-#endif // CHRE_TOKENIZED_LOGGING_ENABLED
diff --git a/core/sensor_request_manager.cc b/core/sensor_request_manager.cc
index 6230ccb..2888ae0 100644
--- a/core/sensor_request_manager.cc
+++ b/core/sensor_request_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_SENSORS_SUPPORT_ENABLED
+
#include "chre/core/sensor_request_manager.h"
#include "chre/core/event_loop_manager.h"
@@ -939,3 +941,5 @@
}
} // namespace chre
+
+#endif // CHRE_SENSORS_SUPPORT_ENABLED
diff --git a/core/telemetry_manager.cc b/core/telemetry_manager.cc
index 6bc32a7..70e1139 100644
--- a/core/telemetry_manager.cc
+++ b/core/telemetry_manager.cc
@@ -14,13 +14,14 @@
* limitations under the License.
*/
+#ifdef CHRE_TELEMETRY_SUPPORT_ENABLED
+
#include "chre/core/telemetry_manager.h"
#include <pb_encode.h>
#include "chre/core/event_loop_manager.h"
#include "chre/platform/fatal_error.h"
-#include "chre/platform/shared/host_protocol_chre.h"
#include "chre/util/macros.h"
#include "chre/util/nested_data_ptr.h"
#include "chre/util/time.h"
@@ -173,3 +174,5 @@
}
} // namespace chre
+
+#endif // CHRE_TELEMETRY_SUPPORT_ENABLED
diff --git a/core/timer_pool.cc b/core/timer_pool.cc
index 36d032e..bb8b095 100644
--- a/core/timer_pool.cc
+++ b/core/timer_pool.cc
@@ -20,8 +20,8 @@
#include "chre/core/event_loop_common.h"
#include "chre/core/event_loop_manager.h"
#include "chre/platform/fatal_error.h"
+#include "chre/platform/log.h"
#include "chre/platform/system_time.h"
-#include "chre/target_platform/log.h"
#include "chre/util/lock_guard.h"
#include "chre/util/nested_data_ptr.h"
@@ -362,11 +362,9 @@
}
}
- if (!EventLoopManagerSingleton::get()->getEventLoop()
- .deliverEventSync(
- currentTimerRequest.instanceId,
- CHRE_EVENT_TIMER,
- const_cast<void*>(currentTimerRequest.cookie))) {
+ if (!EventLoopManagerSingleton::get()->getEventLoop().distributeEventSync(
+ CHRE_EVENT_TIMER, const_cast<void *>(currentTimerRequest.cookie),
+ currentTimerRequest.instanceId)) {
LOGW("Failed to deliver timer event");
}
}
diff --git a/core/wifi_request_manager.cc b/core/wifi_request_manager.cc
index 8aa4649..b95405b 100644
--- a/core/wifi_request_manager.cc
+++ b/core/wifi_request_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_WIFI_SUPPORT_ENABLED
+
#include "chre/core/wifi_request_manager.h"
#include <cinttypes>
@@ -1418,3 +1420,5 @@
}
} // namespace chre
+
+#endif // CHRE_WIFI_SUPPORT_ENABLED
diff --git a/core/wwan_request_manager.cc b/core/wwan_request_manager.cc
index 9fbbc92..b6ccefd 100644
--- a/core/wwan_request_manager.cc
+++ b/core/wwan_request_manager.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_WWAN_SUPPORT_ENABLED
+
#include "chre/core/wwan_request_manager.h"
#include "chre/core/event_loop_manager.h"
@@ -127,3 +129,5 @@
}
} // namespace chre
+
+#endif // CHRE_WWAN_SUPPORT_ENABLED
diff --git a/external/pigweed/pw_assert_nanoapp/public_overrides/pw_assert_backend/check_backend.h b/external/pigweed/pw_assert_nanoapp/public_overrides/pw_assert_backend/check_backend.h
index 99029d9..b17032f 100644
--- a/external/pigweed/pw_assert_nanoapp/public_overrides/pw_assert_backend/check_backend.h
+++ b/external/pigweed/pw_assert_nanoapp/public_overrides/pw_assert_backend/check_backend.h
@@ -35,6 +35,7 @@
#define PW_HANDLE_ASSERT_FAILURE(condition_string, message, ...) \
do { \
PW_LOG(PW_LOG_LEVEL_FATAL, \
+ PW_LOG_LEVEL, \
PW_LOG_MODULE_NAME, \
PW_LOG_FLAGS, \
"Check failed: " condition_string ". " message, \
@@ -51,6 +52,7 @@
message, ...) \
do { \
PW_LOG(PW_LOG_LEVEL_FATAL, \
+ PW_LOG_LEVEL, \
PW_LOG_MODULE_NAME, \
PW_LOG_FLAGS, \
"Check failed: " \
diff --git a/host/common/config_util.cc b/host/common/config_util.cc
index fa6e985..c4e49f7 100644
--- a/host/common/config_util.cc
+++ b/host/common/config_util.cc
@@ -39,8 +39,9 @@
if (!std::regex_match(entry->d_name, match, regex)) {
continue;
}
- LOGD("Found nanoapp: %s", match[1]);
- outNanoapps.push_back(match[1]);
+ std::string nanoapp_name = match[1];
+ LOGD("Found nanoapp: %s", nanoapp_name.c_str());
+ outNanoapps.push_back(nanoapp_name);
}
closedir(dir);
return true;
diff --git a/host/common/host_protocol_host.cc b/host/common/host_protocol_host.cc
index a24ec94..830f1a5 100644
--- a/host/common/host_protocol_host.cc
+++ b/host/common/host_protocol_host.cc
@@ -88,9 +88,7 @@
break;
default:
- LOGW("Got invalid/unexpected message type %" PRIu8,
- static_cast<uint8_t>(msg.type));
- success = false;
+ success = handlers.handleContextHubV4Message(msg);
}
}
diff --git a/host/common/include/chre_host/generated/host_messages_generated.h b/host/common/include/chre_host/generated/host_messages_generated.h
index b386f8d..613b27f 100644
--- a/host/common/include/chre_host/generated/host_messages_generated.h
+++ b/host/common/include/chre_host/generated/host_messages_generated.h
@@ -145,6 +145,90 @@
struct PulseResponseBuilder;
struct PulseResponseT;
+struct LeCocChannelInfo;
+struct LeCocChannelInfoBuilder;
+struct LeCocChannelInfoT;
+
+struct BtSocketOpen;
+struct BtSocketOpenBuilder;
+struct BtSocketOpenT;
+
+struct BtSocketOpenResponse;
+struct BtSocketOpenResponseBuilder;
+struct BtSocketOpenResponseT;
+
+struct BtSocketClose;
+struct BtSocketCloseBuilder;
+struct BtSocketCloseT;
+
+struct BtSocketCloseResponse;
+struct BtSocketCloseResponseBuilder;
+struct BtSocketCloseResponseT;
+
+struct VendorHubInfo;
+struct VendorHubInfoBuilder;
+struct VendorHubInfoT;
+
+struct MessageHub;
+struct MessageHubBuilder;
+struct MessageHubT;
+
+struct RegisterMessageHub;
+struct RegisterMessageHubBuilder;
+struct RegisterMessageHubT;
+
+struct UnregisterMessageHub;
+struct UnregisterMessageHubBuilder;
+struct UnregisterMessageHubT;
+
+struct EndpointId;
+struct EndpointIdBuilder;
+struct EndpointIdT;
+
+struct Service;
+struct ServiceBuilder;
+struct ServiceT;
+
+struct EndpointInfo;
+struct EndpointInfoBuilder;
+struct EndpointInfoT;
+
+struct RegisterEndpoint;
+struct RegisterEndpointBuilder;
+struct RegisterEndpointT;
+
+struct UnregisterEndpoint;
+struct UnregisterEndpointBuilder;
+struct UnregisterEndpointT;
+
+struct GetMessageHubsAndEndpointsRequest;
+struct GetMessageHubsAndEndpointsRequestBuilder;
+struct GetMessageHubsAndEndpointsRequestT;
+
+struct GetMessageHubsAndEndpointsResponse;
+struct GetMessageHubsAndEndpointsResponseBuilder;
+struct GetMessageHubsAndEndpointsResponseT;
+
+struct OpenEndpointSessionRequest;
+struct OpenEndpointSessionRequestBuilder;
+struct OpenEndpointSessionRequestT;
+
+struct EndpointSessionOpened;
+struct EndpointSessionOpenedBuilder;
+struct EndpointSessionOpenedT;
+
+struct EndpointSessionClosed;
+struct EndpointSessionClosedBuilder;
+struct EndpointSessionClosedT;
+
+struct EndpointSessionMessage;
+struct EndpointSessionMessageBuilder;
+struct EndpointSessionMessageT;
+
+struct EndpointSessionMessageDeliveryStatus;
+struct EndpointSessionMessageDeliveryStatusBuilder;
+struct EndpointSessionMessageDeliveryStatusT;
+
struct HostAddress;
struct MessageContainer;
@@ -327,6 +411,362 @@
return EnumNamesBtSnoopDirection()[index];
}
+enum class ChannelInfo : uint8_t {
+ NONE = 0,
+ LeCocChannelInfo = 1,
+ MIN = NONE,
+ MAX = LeCocChannelInfo
+};
+
+inline const ChannelInfo (&EnumValuesChannelInfo())[2] {
+ static const ChannelInfo values[] = {
+ ChannelInfo::NONE,
+ ChannelInfo::LeCocChannelInfo
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesChannelInfo() {
+ static const char * const names[3] = {
+ "NONE",
+ "LeCocChannelInfo",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameChannelInfo(ChannelInfo e) {
+ if (flatbuffers::IsOutRange(e, ChannelInfo::NONE, ChannelInfo::LeCocChannelInfo)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesChannelInfo()[index];
+}
+
+template<typename T> struct ChannelInfoTraits {
+ static const ChannelInfo enum_value = ChannelInfo::NONE;
+};
+
+template<> struct ChannelInfoTraits<chre::fbs::LeCocChannelInfo> {
+ static const ChannelInfo enum_value = ChannelInfo::LeCocChannelInfo;
+};
+
+struct ChannelInfoUnion {
+ ChannelInfo type;
+ void *value;
+
+ ChannelInfoUnion() : type(ChannelInfo::NONE), value(nullptr) {}
+ ChannelInfoUnion(ChannelInfoUnion&& u) FLATBUFFERS_NOEXCEPT :
+ type(ChannelInfo::NONE), value(nullptr)
+ { std::swap(type, u.type); std::swap(value, u.value); }
+ ChannelInfoUnion(const ChannelInfoUnion &);
+ ChannelInfoUnion &operator=(const ChannelInfoUnion &u)
+ { ChannelInfoUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+ ChannelInfoUnion &operator=(ChannelInfoUnion &&u) FLATBUFFERS_NOEXCEPT
+ { std::swap(type, u.type); std::swap(value, u.value); return *this; }
+ ~ChannelInfoUnion() { Reset(); }
+
+ void Reset();
+
+#ifndef FLATBUFFERS_CPP98_STL
+ template <typename T>
+ void Set(T&& val) {
+ using RT = typename std::remove_reference<T>::type;
+ Reset();
+ type = ChannelInfoTraits<typename RT::TableType>::enum_value;
+ if (type != ChannelInfo::NONE) {
+ value = new RT(std::forward<T>(val));
+ }
+ }
+#endif // FLATBUFFERS_CPP98_STL
+
+ static void *UnPack(const void *obj, ChannelInfo type, const flatbuffers::resolver_function_t *resolver);
+ flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+ chre::fbs::LeCocChannelInfoT *AsLeCocChannelInfo() {
+ return type == ChannelInfo::LeCocChannelInfo ?
+ reinterpret_cast<chre::fbs::LeCocChannelInfoT *>(value) : nullptr;
+ }
+ const chre::fbs::LeCocChannelInfoT *AsLeCocChannelInfo() const {
+ return type == ChannelInfo::LeCocChannelInfo ?
+ reinterpret_cast<const chre::fbs::LeCocChannelInfoT *>(value) : nullptr;
+ }
+};
+
+bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type);
+bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+enum class BtSocketOpenStatus : int8_t {
+ SUCCESS = 0,
+ FAILURE = 1,
+ MIN = SUCCESS,
+ MAX = FAILURE
+};
+
+inline const BtSocketOpenStatus (&EnumValuesBtSocketOpenStatus())[2] {
+ static const BtSocketOpenStatus values[] = {
+ BtSocketOpenStatus::SUCCESS,
+ BtSocketOpenStatus::FAILURE
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesBtSocketOpenStatus() {
+ static const char * const names[3] = {
+ "SUCCESS",
+ "FAILURE",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameBtSocketOpenStatus(BtSocketOpenStatus e) {
+ if (flatbuffers::IsOutRange(e, BtSocketOpenStatus::SUCCESS, BtSocketOpenStatus::FAILURE)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesBtSocketOpenStatus()[index];
+}
+
+enum class MessageHubDetails : uint8_t {
+ NONE = 0,
+ HubInfoResponse = 1,
+ VendorHubInfo = 2,
+ MIN = NONE,
+ MAX = VendorHubInfo
+};
+
+inline const MessageHubDetails (&EnumValuesMessageHubDetails())[3] {
+ static const MessageHubDetails values[] = {
+ MessageHubDetails::NONE,
+ MessageHubDetails::HubInfoResponse,
+ MessageHubDetails::VendorHubInfo
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesMessageHubDetails() {
+ static const char * const names[4] = {
+ "NONE",
+ "HubInfoResponse",
+ "VendorHubInfo",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameMessageHubDetails(MessageHubDetails e) {
+ if (flatbuffers::IsOutRange(e, MessageHubDetails::NONE, MessageHubDetails::VendorHubInfo)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesMessageHubDetails()[index];
+}
+
+template<typename T> struct MessageHubDetailsTraits {
+ static const MessageHubDetails enum_value = MessageHubDetails::NONE;
+};
+
+template<> struct MessageHubDetailsTraits<chre::fbs::HubInfoResponse> {
+ static const MessageHubDetails enum_value = MessageHubDetails::HubInfoResponse;
+};
+
+template<> struct MessageHubDetailsTraits<chre::fbs::VendorHubInfo> {
+ static const MessageHubDetails enum_value = MessageHubDetails::VendorHubInfo;
+};
+
+struct MessageHubDetailsUnion {
+ MessageHubDetails type;
+ void *value;
+
+ MessageHubDetailsUnion() : type(MessageHubDetails::NONE), value(nullptr) {}
+ MessageHubDetailsUnion(MessageHubDetailsUnion&& u) FLATBUFFERS_NOEXCEPT :
+ type(MessageHubDetails::NONE), value(nullptr)
+ { std::swap(type, u.type); std::swap(value, u.value); }
+ MessageHubDetailsUnion(const MessageHubDetailsUnion &);
+ MessageHubDetailsUnion &operator=(const MessageHubDetailsUnion &u)
+ { MessageHubDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+ MessageHubDetailsUnion &operator=(MessageHubDetailsUnion &&u) FLATBUFFERS_NOEXCEPT
+ { std::swap(type, u.type); std::swap(value, u.value); return *this; }
+ ~MessageHubDetailsUnion() { Reset(); }
+
+ void Reset();
+
+#ifndef FLATBUFFERS_CPP98_STL
+ template <typename T>
+ void Set(T&& val) {
+ using RT = typename std::remove_reference<T>::type;
+ Reset();
+ type = MessageHubDetailsTraits<typename RT::TableType>::enum_value;
+ if (type != MessageHubDetails::NONE) {
+ value = new RT(std::forward<T>(val));
+ }
+ }
+#endif // FLATBUFFERS_CPP98_STL
+
+ static void *UnPack(const void *obj, MessageHubDetails type, const flatbuffers::resolver_function_t *resolver);
+ flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+ chre::fbs::HubInfoResponseT *AsHubInfoResponse() {
+ return type == MessageHubDetails::HubInfoResponse ?
+ reinterpret_cast<chre::fbs::HubInfoResponseT *>(value) : nullptr;
+ }
+ const chre::fbs::HubInfoResponseT *AsHubInfoResponse() const {
+ return type == MessageHubDetails::HubInfoResponse ?
+ reinterpret_cast<const chre::fbs::HubInfoResponseT *>(value) : nullptr;
+ }
+ chre::fbs::VendorHubInfoT *AsVendorHubInfo() {
+ return type == MessageHubDetails::VendorHubInfo ?
+ reinterpret_cast<chre::fbs::VendorHubInfoT *>(value) : nullptr;
+ }
+ const chre::fbs::VendorHubInfoT *AsVendorHubInfo() const {
+ return type == MessageHubDetails::VendorHubInfo ?
+ reinterpret_cast<const chre::fbs::VendorHubInfoT *>(value) : nullptr;
+ }
+};
+
+bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type);
+bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// An enum describing the type of an endpoint.
+enum class EndpointType : uint8_t {
+ INVALID = 0,
+ /// The endpoint is part of the Android Framework
+ FRAMEWORK = 1,
+ /// The endpoint is an Android app
+ APP = 2,
+ /// The endpoint is a native Android program
+ NATIVE = 3,
+ /// The endpoint is a nanoapp
+ NANOAPP = 4,
+ /// A generic, non-nanoapp endpoint
+ GENERIC = 5,
+ MIN = INVALID,
+ MAX = GENERIC
+};
+
+inline const EndpointType (&EnumValuesEndpointType())[6] {
+ static const EndpointType values[] = {
+ EndpointType::INVALID,
+ EndpointType::FRAMEWORK,
+ EndpointType::APP,
+ EndpointType::NATIVE,
+ EndpointType::NANOAPP,
+ EndpointType::GENERIC
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesEndpointType() {
+ static const char * const names[7] = {
+ "INVALID",
+ "FRAMEWORK",
+ "APP",
+ "NATIVE",
+ "NANOAPP",
+ "GENERIC",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameEndpointType(EndpointType e) {
+ if (flatbuffers::IsOutRange(e, EndpointType::INVALID, EndpointType::GENERIC)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesEndpointType()[index];
+}
+
+enum class RpcFormat : uint8_t {
+ /// Fully custom format
+ CUSTOM = 0,
+ /// Stable AIDL defined interface using Binder marshalling
+ AIDL = 1,
+ /// Pigweed RPC defined interface using Protobuf marshalling
+ PW_RPC = 2,
+ MIN = CUSTOM,
+ MAX = PW_RPC
+};
+
+inline const RpcFormat (&EnumValuesRpcFormat())[3] {
+ static const RpcFormat values[] = {
+ RpcFormat::CUSTOM,
+ RpcFormat::AIDL,
+ RpcFormat::PW_RPC
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesRpcFormat() {
+ static const char * const names[4] = {
+ "CUSTOM",
+ "AIDL",
+ "PW_RPC",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameRpcFormat(RpcFormat e) {
+ if (flatbuffers::IsOutRange(e, RpcFormat::CUSTOM, RpcFormat::PW_RPC)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesRpcFormat()[index];
+}
+
+/// "Reason"s for stopping an endpoint or session over an endpoint.
+enum class Reason : uint8_t {
+ /// Unspecified reason.
+ UNSPECIFIED = 0,
+ /// Out of memory. There's not enough memory to perform this operation.
+ OUT_OF_MEMORY = 1,
+ /// Timeout. This operation timed out.
+ TIMEOUT = 2,
+ /// Endpoint rejected this openEndpointSession request.
+ OPEN_ENDPOINT_SESSION_REQUEST_REJECTED = 3,
+ /// Endpoint requested closeEndpointSession.
+ CLOSE_ENDPOINT_SESSION_REQUESTED = 4,
+ /// Invalid endpoint.
+ ENDPOINT_INVALID = 5,
+ /// Endpoint is now stopped.
+ ENDPOINT_GONE = 6,
+ /// Endpoint crashed.
+ ENDPOINT_CRASHED = 7,
+ /// Hub was reset or is resetting.
+ HUB_RESET = 8,
+ MIN = UNSPECIFIED,
+ MAX = HUB_RESET
+};
+
+inline const Reason (&EnumValuesReason())[9] {
+ static const Reason values[] = {
+ Reason::UNSPECIFIED,
+ Reason::OUT_OF_MEMORY,
+ Reason::TIMEOUT,
+ Reason::OPEN_ENDPOINT_SESSION_REQUEST_REJECTED,
+ Reason::CLOSE_ENDPOINT_SESSION_REQUESTED,
+ Reason::ENDPOINT_INVALID,
+ Reason::ENDPOINT_GONE,
+ Reason::ENDPOINT_CRASHED,
+ Reason::HUB_RESET
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesReason() {
+ static const char * const names[10] = {
+ "UNSPECIFIED",
+ "OUT_OF_MEMORY",
+ "TIMEOUT",
+ "OPEN_ENDPOINT_SESSION_REQUEST_REJECTED",
+ "CLOSE_ENDPOINT_SESSION_REQUESTED",
+ "ENDPOINT_INVALID",
+ "ENDPOINT_GONE",
+ "ENDPOINT_CRASHED",
+ "HUB_RESET",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameReason(Reason e) {
+ if (flatbuffers::IsOutRange(e, Reason::UNSPECIFIED, Reason::HUB_RESET)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesReason()[index];
+}
+
/// A union that joins together all possible messages. Note that in FlatBuffers,
/// unions have an implicit type
enum class ChreMessage : uint8_t {
@@ -363,11 +803,26 @@
PulseResponse = 30,
NanoappTokenDatabaseInfo = 31,
MessageDeliveryStatus = 32,
+ BtSocketOpen = 33,
+ BtSocketOpenResponse = 34,
+ BtSocketClose = 35,
+ BtSocketCloseResponse = 36,
+ GetMessageHubsAndEndpointsRequest = 37,
+ GetMessageHubsAndEndpointsResponse = 38,
+ RegisterMessageHub = 39,
+ UnregisterMessageHub = 40,
+ RegisterEndpoint = 41,
+ UnregisterEndpoint = 42,
+ OpenEndpointSessionRequest = 43,
+ EndpointSessionOpened = 44,
+ EndpointSessionClosed = 45,
+ EndpointSessionMessage = 46,
+ EndpointSessionMessageDeliveryStatus = 47,
MIN = NONE,
- MAX = MessageDeliveryStatus
+ MAX = EndpointSessionMessageDeliveryStatus
};
-inline const ChreMessage (&EnumValuesChreMessage())[33] {
+inline const ChreMessage (&EnumValuesChreMessage())[48] {
static const ChreMessage values[] = {
ChreMessage::NONE,
ChreMessage::NanoappMessage,
@@ -401,13 +856,28 @@
ChreMessage::PulseRequest,
ChreMessage::PulseResponse,
ChreMessage::NanoappTokenDatabaseInfo,
- ChreMessage::MessageDeliveryStatus
+ ChreMessage::MessageDeliveryStatus,
+ ChreMessage::BtSocketOpen,
+ ChreMessage::BtSocketOpenResponse,
+ ChreMessage::BtSocketClose,
+ ChreMessage::BtSocketCloseResponse,
+ ChreMessage::GetMessageHubsAndEndpointsRequest,
+ ChreMessage::GetMessageHubsAndEndpointsResponse,
+ ChreMessage::RegisterMessageHub,
+ ChreMessage::UnregisterMessageHub,
+ ChreMessage::RegisterEndpoint,
+ ChreMessage::UnregisterEndpoint,
+ ChreMessage::OpenEndpointSessionRequest,
+ ChreMessage::EndpointSessionOpened,
+ ChreMessage::EndpointSessionClosed,
+ ChreMessage::EndpointSessionMessage,
+ ChreMessage::EndpointSessionMessageDeliveryStatus
};
return values;
}
inline const char * const *EnumNamesChreMessage() {
- static const char * const names[34] = {
+ static const char * const names[49] = {
"NONE",
"NanoappMessage",
"HubInfoRequest",
@@ -441,13 +911,28 @@
"PulseResponse",
"NanoappTokenDatabaseInfo",
"MessageDeliveryStatus",
+ "BtSocketOpen",
+ "BtSocketOpenResponse",
+ "BtSocketClose",
+ "BtSocketCloseResponse",
+ "GetMessageHubsAndEndpointsRequest",
+ "GetMessageHubsAndEndpointsResponse",
+ "RegisterMessageHub",
+ "UnregisterMessageHub",
+ "RegisterEndpoint",
+ "UnregisterEndpoint",
+ "OpenEndpointSessionRequest",
+ "EndpointSessionOpened",
+ "EndpointSessionClosed",
+ "EndpointSessionMessage",
+ "EndpointSessionMessageDeliveryStatus",
nullptr
};
return names;
}
inline const char *EnumNameChreMessage(ChreMessage e) {
- if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::MessageDeliveryStatus)) return "";
+ if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::EndpointSessionMessageDeliveryStatus)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesChreMessage()[index];
}
@@ -584,6 +1069,66 @@
static const ChreMessage enum_value = ChreMessage::MessageDeliveryStatus;
};
+template<> struct ChreMessageTraits<chre::fbs::BtSocketOpen> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketOpen;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketOpenResponse> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketOpenResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketClose> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketClose;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketCloseResponse> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketCloseResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsRequest> {
+ static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsRequest;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsResponse> {
+ static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::RegisterMessageHub> {
+ static const ChreMessage enum_value = ChreMessage::RegisterMessageHub;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::UnregisterMessageHub> {
+ static const ChreMessage enum_value = ChreMessage::UnregisterMessageHub;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::RegisterEndpoint> {
+ static const ChreMessage enum_value = ChreMessage::RegisterEndpoint;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::UnregisterEndpoint> {
+ static const ChreMessage enum_value = ChreMessage::UnregisterEndpoint;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::OpenEndpointSessionRequest> {
+ static const ChreMessage enum_value = ChreMessage::OpenEndpointSessionRequest;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionOpened> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionOpened;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionClosed> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionClosed;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessage> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionMessage;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessageDeliveryStatus> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionMessageDeliveryStatus;
+};
+
struct ChreMessageUnion {
ChreMessage type;
void *value;
@@ -872,6 +1417,126 @@
return type == ChreMessage::MessageDeliveryStatus ?
reinterpret_cast<const chre::fbs::MessageDeliveryStatusT *>(value) : nullptr;
}
+ chre::fbs::BtSocketOpenT *AsBtSocketOpen() {
+ return type == ChreMessage::BtSocketOpen ?
+ reinterpret_cast<chre::fbs::BtSocketOpenT *>(value) : nullptr;
+ }
+ const chre::fbs::BtSocketOpenT *AsBtSocketOpen() const {
+ return type == ChreMessage::BtSocketOpen ?
+ reinterpret_cast<const chre::fbs::BtSocketOpenT *>(value) : nullptr;
+ }
+ chre::fbs::BtSocketOpenResponseT *AsBtSocketOpenResponse() {
+ return type == ChreMessage::BtSocketOpenResponse ?
+ reinterpret_cast<chre::fbs::BtSocketOpenResponseT *>(value) : nullptr;
+ }
+ const chre::fbs::BtSocketOpenResponseT *AsBtSocketOpenResponse() const {
+ return type == ChreMessage::BtSocketOpenResponse ?
+ reinterpret_cast<const chre::fbs::BtSocketOpenResponseT *>(value) : nullptr;
+ }
+ chre::fbs::BtSocketCloseT *AsBtSocketClose() {
+ return type == ChreMessage::BtSocketClose ?
+ reinterpret_cast<chre::fbs::BtSocketCloseT *>(value) : nullptr;
+ }
+ const chre::fbs::BtSocketCloseT *AsBtSocketClose() const {
+ return type == ChreMessage::BtSocketClose ?
+ reinterpret_cast<const chre::fbs::BtSocketCloseT *>(value) : nullptr;
+ }
+ chre::fbs::BtSocketCloseResponseT *AsBtSocketCloseResponse() {
+ return type == ChreMessage::BtSocketCloseResponse ?
+ reinterpret_cast<chre::fbs::BtSocketCloseResponseT *>(value) : nullptr;
+ }
+ const chre::fbs::BtSocketCloseResponseT *AsBtSocketCloseResponse() const {
+ return type == ChreMessage::BtSocketCloseResponse ?
+ reinterpret_cast<const chre::fbs::BtSocketCloseResponseT *>(value) : nullptr;
+ }
+ chre::fbs::GetMessageHubsAndEndpointsRequestT *AsGetMessageHubsAndEndpointsRequest() {
+ return type == ChreMessage::GetMessageHubsAndEndpointsRequest ?
+ reinterpret_cast<chre::fbs::GetMessageHubsAndEndpointsRequestT *>(value) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsRequestT *AsGetMessageHubsAndEndpointsRequest() const {
+ return type == ChreMessage::GetMessageHubsAndEndpointsRequest ?
+ reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequestT *>(value) : nullptr;
+ }
+ chre::fbs::GetMessageHubsAndEndpointsResponseT *AsGetMessageHubsAndEndpointsResponse() {
+ return type == ChreMessage::GetMessageHubsAndEndpointsResponse ?
+ reinterpret_cast<chre::fbs::GetMessageHubsAndEndpointsResponseT *>(value) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsResponseT *AsGetMessageHubsAndEndpointsResponse() const {
+ return type == ChreMessage::GetMessageHubsAndEndpointsResponse ?
+ reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponseT *>(value) : nullptr;
+ }
+ chre::fbs::RegisterMessageHubT *AsRegisterMessageHub() {
+ return type == ChreMessage::RegisterMessageHub ?
+ reinterpret_cast<chre::fbs::RegisterMessageHubT *>(value) : nullptr;
+ }
+ const chre::fbs::RegisterMessageHubT *AsRegisterMessageHub() const {
+ return type == ChreMessage::RegisterMessageHub ?
+ reinterpret_cast<const chre::fbs::RegisterMessageHubT *>(value) : nullptr;
+ }
+ chre::fbs::UnregisterMessageHubT *AsUnregisterMessageHub() {
+ return type == ChreMessage::UnregisterMessageHub ?
+ reinterpret_cast<chre::fbs::UnregisterMessageHubT *>(value) : nullptr;
+ }
+ const chre::fbs::UnregisterMessageHubT *AsUnregisterMessageHub() const {
+ return type == ChreMessage::UnregisterMessageHub ?
+ reinterpret_cast<const chre::fbs::UnregisterMessageHubT *>(value) : nullptr;
+ }
+ chre::fbs::RegisterEndpointT *AsRegisterEndpoint() {
+ return type == ChreMessage::RegisterEndpoint ?
+ reinterpret_cast<chre::fbs::RegisterEndpointT *>(value) : nullptr;
+ }
+ const chre::fbs::RegisterEndpointT *AsRegisterEndpoint() const {
+ return type == ChreMessage::RegisterEndpoint ?
+ reinterpret_cast<const chre::fbs::RegisterEndpointT *>(value) : nullptr;
+ }
+ chre::fbs::UnregisterEndpointT *AsUnregisterEndpoint() {
+ return type == ChreMessage::UnregisterEndpoint ?
+ reinterpret_cast<chre::fbs::UnregisterEndpointT *>(value) : nullptr;
+ }
+ const chre::fbs::UnregisterEndpointT *AsUnregisterEndpoint() const {
+ return type == ChreMessage::UnregisterEndpoint ?
+ reinterpret_cast<const chre::fbs::UnregisterEndpointT *>(value) : nullptr;
+ }
+ chre::fbs::OpenEndpointSessionRequestT *AsOpenEndpointSessionRequest() {
+ return type == ChreMessage::OpenEndpointSessionRequest ?
+ reinterpret_cast<chre::fbs::OpenEndpointSessionRequestT *>(value) : nullptr;
+ }
+ const chre::fbs::OpenEndpointSessionRequestT *AsOpenEndpointSessionRequest() const {
+ return type == ChreMessage::OpenEndpointSessionRequest ?
+ reinterpret_cast<const chre::fbs::OpenEndpointSessionRequestT *>(value) : nullptr;
+ }
+ chre::fbs::EndpointSessionOpenedT *AsEndpointSessionOpened() {
+ return type == ChreMessage::EndpointSessionOpened ?
+ reinterpret_cast<chre::fbs::EndpointSessionOpenedT *>(value) : nullptr;
+ }
+ const chre::fbs::EndpointSessionOpenedT *AsEndpointSessionOpened() const {
+ return type == ChreMessage::EndpointSessionOpened ?
+ reinterpret_cast<const chre::fbs::EndpointSessionOpenedT *>(value) : nullptr;
+ }
+ chre::fbs::EndpointSessionClosedT *AsEndpointSessionClosed() {
+ return type == ChreMessage::EndpointSessionClosed ?
+ reinterpret_cast<chre::fbs::EndpointSessionClosedT *>(value) : nullptr;
+ }
+ const chre::fbs::EndpointSessionClosedT *AsEndpointSessionClosed() const {
+ return type == ChreMessage::EndpointSessionClosed ?
+ reinterpret_cast<const chre::fbs::EndpointSessionClosedT *>(value) : nullptr;
+ }
+ chre::fbs::EndpointSessionMessageT *AsEndpointSessionMessage() {
+ return type == ChreMessage::EndpointSessionMessage ?
+ reinterpret_cast<chre::fbs::EndpointSessionMessageT *>(value) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessageT *AsEndpointSessionMessage() const {
+ return type == ChreMessage::EndpointSessionMessage ?
+ reinterpret_cast<const chre::fbs::EndpointSessionMessageT *>(value) : nullptr;
+ }
+ chre::fbs::EndpointSessionMessageDeliveryStatusT *AsEndpointSessionMessageDeliveryStatus() {
+ return type == ChreMessage::EndpointSessionMessageDeliveryStatus ?
+ reinterpret_cast<chre::fbs::EndpointSessionMessageDeliveryStatusT *>(value) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessageDeliveryStatusT *AsEndpointSessionMessageDeliveryStatus() const {
+ return type == ChreMessage::EndpointSessionMessageDeliveryStatus ?
+ reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatusT *>(value) : nullptr;
+ }
};
bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
@@ -3888,6 +4553,2027 @@
flatbuffers::Offset<PulseResponse> CreatePulseResponse(flatbuffers::FlatBufferBuilder &_fbb, const PulseResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+struct LeCocChannelInfoT : public flatbuffers::NativeTable {
+ typedef LeCocChannelInfo TableType;
+ int32_t localCid;
+ int32_t remoteCid;
+ int32_t psm;
+ int32_t localMtu;
+ int32_t remoteMtu;
+ int32_t localMps;
+ int32_t remoteMps;
+ int32_t initialRxCredits;
+ int32_t initialTxCredits;
+ LeCocChannelInfoT()
+ : localCid(0),
+ remoteCid(0),
+ psm(0),
+ localMtu(0),
+ remoteMtu(0),
+ localMps(0),
+ remoteMps(0),
+ initialRxCredits(0),
+ initialTxCredits(0) {
+ }
+};
+
+struct LeCocChannelInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef LeCocChannelInfoT NativeTableType;
+ typedef LeCocChannelInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_LOCALCID = 4,
+ VT_REMOTECID = 6,
+ VT_PSM = 8,
+ VT_LOCALMTU = 10,
+ VT_REMOTEMTU = 12,
+ VT_LOCALMPS = 14,
+ VT_REMOTEMPS = 16,
+ VT_INITIALRXCREDITS = 18,
+ VT_INITIALTXCREDITS = 20
+ };
+ int32_t localCid() const {
+ return GetField<int32_t>(VT_LOCALCID, 0);
+ }
+ bool mutate_localCid(int32_t _localCid) {
+ return SetField<int32_t>(VT_LOCALCID, _localCid, 0);
+ }
+ int32_t remoteCid() const {
+ return GetField<int32_t>(VT_REMOTECID, 0);
+ }
+ bool mutate_remoteCid(int32_t _remoteCid) {
+ return SetField<int32_t>(VT_REMOTECID, _remoteCid, 0);
+ }
+ int32_t psm() const {
+ return GetField<int32_t>(VT_PSM, 0);
+ }
+ bool mutate_psm(int32_t _psm) {
+ return SetField<int32_t>(VT_PSM, _psm, 0);
+ }
+ int32_t localMtu() const {
+ return GetField<int32_t>(VT_LOCALMTU, 0);
+ }
+ bool mutate_localMtu(int32_t _localMtu) {
+ return SetField<int32_t>(VT_LOCALMTU, _localMtu, 0);
+ }
+ int32_t remoteMtu() const {
+ return GetField<int32_t>(VT_REMOTEMTU, 0);
+ }
+ bool mutate_remoteMtu(int32_t _remoteMtu) {
+ return SetField<int32_t>(VT_REMOTEMTU, _remoteMtu, 0);
+ }
+ int32_t localMps() const {
+ return GetField<int32_t>(VT_LOCALMPS, 0);
+ }
+ bool mutate_localMps(int32_t _localMps) {
+ return SetField<int32_t>(VT_LOCALMPS, _localMps, 0);
+ }
+ int32_t remoteMps() const {
+ return GetField<int32_t>(VT_REMOTEMPS, 0);
+ }
+ bool mutate_remoteMps(int32_t _remoteMps) {
+ return SetField<int32_t>(VT_REMOTEMPS, _remoteMps, 0);
+ }
+ int32_t initialRxCredits() const {
+ return GetField<int32_t>(VT_INITIALRXCREDITS, 0);
+ }
+ bool mutate_initialRxCredits(int32_t _initialRxCredits) {
+ return SetField<int32_t>(VT_INITIALRXCREDITS, _initialRxCredits, 0);
+ }
+ int32_t initialTxCredits() const {
+ return GetField<int32_t>(VT_INITIALTXCREDITS, 0);
+ }
+ bool mutate_initialTxCredits(int32_t _initialTxCredits) {
+ return SetField<int32_t>(VT_INITIALTXCREDITS, _initialTxCredits, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int32_t>(verifier, VT_LOCALCID) &&
+ VerifyField<int32_t>(verifier, VT_REMOTECID) &&
+ VerifyField<int32_t>(verifier, VT_PSM) &&
+ VerifyField<int32_t>(verifier, VT_LOCALMTU) &&
+ VerifyField<int32_t>(verifier, VT_REMOTEMTU) &&
+ VerifyField<int32_t>(verifier, VT_LOCALMPS) &&
+ VerifyField<int32_t>(verifier, VT_REMOTEMPS) &&
+ VerifyField<int32_t>(verifier, VT_INITIALRXCREDITS) &&
+ VerifyField<int32_t>(verifier, VT_INITIALTXCREDITS) &&
+ verifier.EndTable();
+ }
+ LeCocChannelInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(LeCocChannelInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<LeCocChannelInfo> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeCocChannelInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct LeCocChannelInfoBuilder {
+ typedef LeCocChannelInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_localCid(int32_t localCid) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALCID, localCid, 0);
+ }
+ void add_remoteCid(int32_t remoteCid) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTECID, remoteCid, 0);
+ }
+ void add_psm(int32_t psm) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_PSM, psm, 0);
+ }
+ void add_localMtu(int32_t localMtu) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMTU, localMtu, 0);
+ }
+ void add_remoteMtu(int32_t remoteMtu) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMTU, remoteMtu, 0);
+ }
+ void add_localMps(int32_t localMps) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMPS, localMps, 0);
+ }
+ void add_remoteMps(int32_t remoteMps) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMPS, remoteMps, 0);
+ }
+ void add_initialRxCredits(int32_t initialRxCredits) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALRXCREDITS, initialRxCredits, 0);
+ }
+ void add_initialTxCredits(int32_t initialTxCredits) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALTXCREDITS, initialTxCredits, 0);
+ }
+ explicit LeCocChannelInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ LeCocChannelInfoBuilder &operator=(const LeCocChannelInfoBuilder &);
+ flatbuffers::Offset<LeCocChannelInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<LeCocChannelInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<LeCocChannelInfo> CreateLeCocChannelInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t localCid = 0,
+ int32_t remoteCid = 0,
+ int32_t psm = 0,
+ int32_t localMtu = 0,
+ int32_t remoteMtu = 0,
+ int32_t localMps = 0,
+ int32_t remoteMps = 0,
+ int32_t initialRxCredits = 0,
+ int32_t initialTxCredits = 0) {
+ LeCocChannelInfoBuilder builder_(_fbb);
+ builder_.add_initialTxCredits(initialTxCredits);
+ builder_.add_initialRxCredits(initialRxCredits);
+ builder_.add_remoteMps(remoteMps);
+ builder_.add_localMps(localMps);
+ builder_.add_remoteMtu(remoteMtu);
+ builder_.add_localMtu(localMtu);
+ builder_.add_psm(psm);
+ builder_.add_remoteCid(remoteCid);
+ builder_.add_localCid(localCid);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<LeCocChannelInfo> CreateLeCocChannelInfo(flatbuffers::FlatBufferBuilder &_fbb, const LeCocChannelInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct BtSocketOpenT : public flatbuffers::NativeTable {
+ typedef BtSocketOpen TableType;
+ int64_t socketId;
+ std::vector<int8_t> name;
+ int32_t aclConnectionHandle;
+ chre::fbs::ChannelInfoUnion channelInfo;
+ int64_t hubId;
+ int64_t endpointId;
+ BtSocketOpenT()
+ : socketId(0),
+ aclConnectionHandle(0),
+ hubId(0),
+ endpointId(0) {
+ }
+};
+
+struct BtSocketOpen FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketOpenT NativeTableType;
+ typedef BtSocketOpenBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_NAME = 6,
+ VT_ACLCONNECTIONHANDLE = 8,
+ VT_CHANNELINFO_TYPE = 10,
+ VT_CHANNELINFO = 12,
+ VT_HUBID = 14,
+ VT_ENDPOINTID = 16
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ bool mutate_socketId(int64_t _socketId) {
+ return SetField<int64_t>(VT_SOCKETID, _socketId, 0);
+ }
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ flatbuffers::Vector<int8_t> *mutable_name() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ int32_t aclConnectionHandle() const {
+ return GetField<int32_t>(VT_ACLCONNECTIONHANDLE, 0);
+ }
+ bool mutate_aclConnectionHandle(int32_t _aclConnectionHandle) {
+ return SetField<int32_t>(VT_ACLCONNECTIONHANDLE, _aclConnectionHandle, 0);
+ }
+ chre::fbs::ChannelInfo channelInfo_type() const {
+ return static_cast<chre::fbs::ChannelInfo>(GetField<uint8_t>(VT_CHANNELINFO_TYPE, 0));
+ }
+ const void *channelInfo() const {
+ return GetPointer<const void *>(VT_CHANNELINFO);
+ }
+ template<typename T> const T *channelInfo_as() const;
+ const chre::fbs::LeCocChannelInfo *channelInfo_as_LeCocChannelInfo() const {
+ return channelInfo_type() == chre::fbs::ChannelInfo::LeCocChannelInfo ? static_cast<const chre::fbs::LeCocChannelInfo *>(channelInfo()) : nullptr;
+ }
+ void *mutable_channelInfo() {
+ return GetPointer<void *>(VT_CHANNELINFO);
+ }
+ int64_t hubId() const {
+ return GetField<int64_t>(VT_HUBID, 0);
+ }
+ bool mutate_hubId(int64_t _hubId) {
+ return SetField<int64_t>(VT_HUBID, _hubId, 0);
+ }
+ int64_t endpointId() const {
+ return GetField<int64_t>(VT_ENDPOINTID, 0);
+ }
+ bool mutate_endpointId(int64_t _endpointId) {
+ return SetField<int64_t>(VT_ENDPOINTID, _endpointId, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<int32_t>(verifier, VT_ACLCONNECTIONHANDLE) &&
+ VerifyField<uint8_t>(verifier, VT_CHANNELINFO_TYPE) &&
+ VerifyOffset(verifier, VT_CHANNELINFO) &&
+ VerifyChannelInfo(verifier, channelInfo(), channelInfo_type()) &&
+ VerifyField<int64_t>(verifier, VT_HUBID) &&
+ VerifyField<int64_t>(verifier, VT_ENDPOINTID) &&
+ verifier.EndTable();
+ }
+ BtSocketOpenT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(BtSocketOpenT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<BtSocketOpen> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+template<> inline const chre::fbs::LeCocChannelInfo *BtSocketOpen::channelInfo_as<chre::fbs::LeCocChannelInfo>() const {
+ return channelInfo_as_LeCocChannelInfo();
+}
+
+struct BtSocketOpenBuilder {
+ typedef BtSocketOpen Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_SOCKETID, socketId, 0);
+ }
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(BtSocketOpen::VT_NAME, name);
+ }
+ void add_aclConnectionHandle(int32_t aclConnectionHandle) {
+ fbb_.AddElement<int32_t>(BtSocketOpen::VT_ACLCONNECTIONHANDLE, aclConnectionHandle, 0);
+ }
+ void add_channelInfo_type(chre::fbs::ChannelInfo channelInfo_type) {
+ fbb_.AddElement<uint8_t>(BtSocketOpen::VT_CHANNELINFO_TYPE, static_cast<uint8_t>(channelInfo_type), 0);
+ }
+ void add_channelInfo(flatbuffers::Offset<void> channelInfo) {
+ fbb_.AddOffset(BtSocketOpen::VT_CHANNELINFO, channelInfo);
+ }
+ void add_hubId(int64_t hubId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_HUBID, hubId, 0);
+ }
+ void add_endpointId(int64_t endpointId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_ENDPOINTID, endpointId, 0);
+ }
+ explicit BtSocketOpenBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketOpenBuilder &operator=(const BtSocketOpenBuilder &);
+ flatbuffers::Offset<BtSocketOpen> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketOpen>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpen(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ int32_t aclConnectionHandle = 0,
+ chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
+ flatbuffers::Offset<void> channelInfo = 0,
+ int64_t hubId = 0,
+ int64_t endpointId = 0) {
+ BtSocketOpenBuilder builder_(_fbb);
+ builder_.add_endpointId(endpointId);
+ builder_.add_hubId(hubId);
+ builder_.add_socketId(socketId);
+ builder_.add_channelInfo(channelInfo);
+ builder_.add_aclConnectionHandle(aclConnectionHandle);
+ builder_.add_name(name);
+ builder_.add_channelInfo_type(channelInfo_type);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpenDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ const std::vector<int8_t> *name = nullptr,
+ int32_t aclConnectionHandle = 0,
+ chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
+ flatbuffers::Offset<void> channelInfo = 0,
+ int64_t hubId = 0,
+ int64_t endpointId = 0) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ return chre::fbs::CreateBtSocketOpen(
+ _fbb,
+ socketId,
+ name__,
+ aclConnectionHandle,
+ channelInfo_type,
+ channelInfo,
+ hubId,
+ endpointId);
+}
+
+flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpen(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct BtSocketOpenResponseT : public flatbuffers::NativeTable {
+ typedef BtSocketOpenResponse TableType;
+ int64_t socketId;
+ chre::fbs::BtSocketOpenStatus status;
+ std::vector<int8_t> reason;
+ BtSocketOpenResponseT()
+ : socketId(0),
+ status(chre::fbs::BtSocketOpenStatus::SUCCESS) {
+ }
+};
+
+struct BtSocketOpenResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketOpenResponseT NativeTableType;
+ typedef BtSocketOpenResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_STATUS = 6,
+ VT_REASON = 8
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ bool mutate_socketId(int64_t _socketId) {
+ return SetField<int64_t>(VT_SOCKETID, _socketId, 0);
+ }
+ chre::fbs::BtSocketOpenStatus status() const {
+ return static_cast<chre::fbs::BtSocketOpenStatus>(GetField<int8_t>(VT_STATUS, 0));
+ }
+ bool mutate_status(chre::fbs::BtSocketOpenStatus _status) {
+ return SetField<int8_t>(VT_STATUS, static_cast<int8_t>(_status), 0);
+ }
+ const flatbuffers::Vector<int8_t> *reason() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ flatbuffers::Vector<int8_t> *mutable_reason() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyField<int8_t>(verifier, VT_STATUS) &&
+ VerifyOffset(verifier, VT_REASON) &&
+ verifier.VerifyVector(reason()) &&
+ verifier.EndTable();
+ }
+ BtSocketOpenResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(BtSocketOpenResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<BtSocketOpenResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct BtSocketOpenResponseBuilder {
+ typedef BtSocketOpenResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketOpenResponse::VT_SOCKETID, socketId, 0);
+ }
+ void add_status(chre::fbs::BtSocketOpenStatus status) {
+ fbb_.AddElement<int8_t>(BtSocketOpenResponse::VT_STATUS, static_cast<int8_t>(status), 0);
+ }
+ void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
+ fbb_.AddOffset(BtSocketOpenResponse::VT_REASON, reason);
+ }
+ explicit BtSocketOpenResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketOpenResponseBuilder &operator=(const BtSocketOpenResponseBuilder &);
+ flatbuffers::Offset<BtSocketOpenResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketOpenResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
+ BtSocketOpenResponseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ builder_.add_reason(reason);
+ builder_.add_status(status);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
+ const std::vector<int8_t> *reason = nullptr) {
+ auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
+ return chre::fbs::CreateBtSocketOpenResponse(
+ _fbb,
+ socketId,
+ status,
+ reason__);
+}
+
+flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponse(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct BtSocketCloseT : public flatbuffers::NativeTable {
+ typedef BtSocketClose TableType;
+ int64_t socketId;
+ std::vector<int8_t> reason;
+ BtSocketCloseT()
+ : socketId(0) {
+ }
+};
+
+struct BtSocketClose FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketCloseT NativeTableType;
+ typedef BtSocketCloseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_REASON = 6
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ bool mutate_socketId(int64_t _socketId) {
+ return SetField<int64_t>(VT_SOCKETID, _socketId, 0);
+ }
+ const flatbuffers::Vector<int8_t> *reason() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ flatbuffers::Vector<int8_t> *mutable_reason() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyOffset(verifier, VT_REASON) &&
+ verifier.VerifyVector(reason()) &&
+ verifier.EndTable();
+ }
+ BtSocketCloseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(BtSocketCloseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<BtSocketClose> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct BtSocketCloseBuilder {
+ typedef BtSocketClose Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketClose::VT_SOCKETID, socketId, 0);
+ }
+ void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
+ fbb_.AddOffset(BtSocketClose::VT_REASON, reason);
+ }
+ explicit BtSocketCloseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketCloseBuilder &operator=(const BtSocketCloseBuilder &);
+ flatbuffers::Offset<BtSocketClose> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketClose>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketClose> CreateBtSocketClose(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
+ BtSocketCloseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ builder_.add_reason(reason);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketClose> CreateBtSocketCloseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ const std::vector<int8_t> *reason = nullptr) {
+ auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
+ return chre::fbs::CreateBtSocketClose(
+ _fbb,
+ socketId,
+ reason__);
+}
+
+flatbuffers::Offset<BtSocketClose> CreateBtSocketClose(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct BtSocketCloseResponseT : public flatbuffers::NativeTable {
+ typedef BtSocketCloseResponse TableType;
+ int64_t socketId;
+ BtSocketCloseResponseT()
+ : socketId(0) {
+ }
+};
+
+struct BtSocketCloseResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketCloseResponseT NativeTableType;
+ typedef BtSocketCloseResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ bool mutate_socketId(int64_t _socketId) {
+ return SetField<int64_t>(VT_SOCKETID, _socketId, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ verifier.EndTable();
+ }
+ BtSocketCloseResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(BtSocketCloseResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<BtSocketCloseResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct BtSocketCloseResponseBuilder {
+ typedef BtSocketCloseResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketCloseResponse::VT_SOCKETID, socketId, 0);
+ }
+ explicit BtSocketCloseResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketCloseResponseBuilder &operator=(const BtSocketCloseResponseBuilder &);
+ flatbuffers::Offset<BtSocketCloseResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketCloseResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketCloseResponse> CreateBtSocketCloseResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0) {
+ BtSocketCloseResponseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<BtSocketCloseResponse> CreateBtSocketCloseResponse(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct VendorHubInfoT : public flatbuffers::NativeTable {
+ typedef VendorHubInfo TableType;
+ std::vector<int8_t> name;
+ uint32_t version;
+ std::vector<uint8_t> extended_info;
+ VendorHubInfoT()
+ : version(0) {
+ }
+};
+
+struct VendorHubInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef VendorHubInfoT NativeTableType;
+ typedef VendorHubInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_NAME = 4,
+ VT_VERSION = 6,
+ VT_EXTENDED_INFO = 8
+ };
+ /// The name of the hub. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ flatbuffers::Vector<int8_t> *mutable_name() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ /// Hub version
+ uint32_t version() const {
+ return GetField<uint32_t>(VT_VERSION, 0);
+ }
+ bool mutate_version(uint32_t _version) {
+ return SetField<uint32_t>(VT_VERSION, _version, 0);
+ }
+ /// Additional vendor-defined data
+ const flatbuffers::Vector<uint8_t> *extended_info() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTENDED_INFO);
+ }
+ flatbuffers::Vector<uint8_t> *mutable_extended_info() {
+ return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_EXTENDED_INFO);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<uint32_t>(verifier, VT_VERSION) &&
+ VerifyOffset(verifier, VT_EXTENDED_INFO) &&
+ verifier.VerifyVector(extended_info()) &&
+ verifier.EndTable();
+ }
+ VendorHubInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(VendorHubInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<VendorHubInfo> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VendorHubInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct VendorHubInfoBuilder {
+ typedef VendorHubInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(VendorHubInfo::VT_NAME, name);
+ }
+ void add_version(uint32_t version) {
+ fbb_.AddElement<uint32_t>(VendorHubInfo::VT_VERSION, version, 0);
+ }
+ void add_extended_info(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info) {
+ fbb_.AddOffset(VendorHubInfo::VT_EXTENDED_INFO, extended_info);
+ }
+ explicit VendorHubInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ VendorHubInfoBuilder &operator=(const VendorHubInfoBuilder &);
+ flatbuffers::Offset<VendorHubInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<VendorHubInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ uint32_t version = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info = 0) {
+ VendorHubInfoBuilder builder_(_fbb);
+ builder_.add_extended_info(extended_info);
+ builder_.add_version(version);
+ builder_.add_name(name);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<int8_t> *name = nullptr,
+ uint32_t version = 0,
+ const std::vector<uint8_t> *extended_info = nullptr) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ auto extended_info__ = extended_info ? _fbb.CreateVector<uint8_t>(*extended_info) : 0;
+ return chre::fbs::CreateVendorHubInfo(
+ _fbb,
+ name__,
+ version,
+ extended_info__);
+}
+
+flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfo(flatbuffers::FlatBufferBuilder &_fbb, const VendorHubInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct MessageHubT : public flatbuffers::NativeTable {
+ typedef MessageHub TableType;
+ int64_t id;
+ chre::fbs::MessageHubDetailsUnion details;
+ MessageHubT()
+ : id(0) {
+ }
+};
+
+struct MessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef MessageHubT NativeTableType;
+ typedef MessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_DETAILS_TYPE = 6,
+ VT_DETAILS = 8
+ };
+ /// The hub id. -1 is reserved and 0 is invalid. 0x416e64726f696400 represents
+ /// the ContextHub service.
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ bool mutate_id(int64_t _id) {
+ return SetField<int64_t>(VT_ID, _id, 0);
+ }
+ chre::fbs::MessageHubDetails details_type() const {
+ return static_cast<chre::fbs::MessageHubDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
+ }
+ /// Details of the message hub.
+ const void *details() const {
+ return GetPointer<const void *>(VT_DETAILS);
+ }
+ template<typename T> const T *details_as() const;
+ const chre::fbs::HubInfoResponse *details_as_HubInfoResponse() const {
+ return details_type() == chre::fbs::MessageHubDetails::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(details()) : nullptr;
+ }
+ const chre::fbs::VendorHubInfo *details_as_VendorHubInfo() const {
+ return details_type() == chre::fbs::MessageHubDetails::VendorHubInfo ? static_cast<const chre::fbs::VendorHubInfo *>(details()) : nullptr;
+ }
+ void *mutable_details() {
+ return GetPointer<void *>(VT_DETAILS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
+ VerifyOffset(verifier, VT_DETAILS) &&
+ VerifyMessageHubDetails(verifier, details(), details_type()) &&
+ verifier.EndTable();
+ }
+ MessageHubT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(MessageHubT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<MessageHub> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+template<> inline const chre::fbs::HubInfoResponse *MessageHub::details_as<chre::fbs::HubInfoResponse>() const {
+ return details_as_HubInfoResponse();
+}
+
+template<> inline const chre::fbs::VendorHubInfo *MessageHub::details_as<chre::fbs::VendorHubInfo>() const {
+ return details_as_VendorHubInfo();
+}
+
+struct MessageHubBuilder {
+ typedef MessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(MessageHub::VT_ID, id, 0);
+ }
+ void add_details_type(chre::fbs::MessageHubDetails details_type) {
+ fbb_.AddElement<uint8_t>(MessageHub::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
+ }
+ void add_details(flatbuffers::Offset<void> details) {
+ fbb_.AddOffset(MessageHub::VT_DETAILS, details);
+ }
+ explicit MessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ MessageHubBuilder &operator=(const MessageHubBuilder &);
+ flatbuffers::Offset<MessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<MessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<MessageHub> CreateMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0,
+ chre::fbs::MessageHubDetails details_type = chre::fbs::MessageHubDetails::NONE,
+ flatbuffers::Offset<void> details = 0) {
+ MessageHubBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_details(details);
+ builder_.add_details_type(details_type);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<MessageHub> CreateMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const MessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RegisterMessageHubT : public flatbuffers::NativeTable {
+ typedef RegisterMessageHub TableType;
+ std::unique_ptr<chre::fbs::MessageHubT> hub;
+ RegisterMessageHubT() {
+ }
+};
+
+struct RegisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef RegisterMessageHubT NativeTableType;
+ typedef RegisterMessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUB = 4
+ };
+ const chre::fbs::MessageHub *hub() const {
+ return GetPointer<const chre::fbs::MessageHub *>(VT_HUB);
+ }
+ chre::fbs::MessageHub *mutable_hub() {
+ return GetPointer<chre::fbs::MessageHub *>(VT_HUB);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_HUB) &&
+ verifier.VerifyTable(hub()) &&
+ verifier.EndTable();
+ }
+ RegisterMessageHubT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(RegisterMessageHubT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<RegisterMessageHub> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegisterMessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RegisterMessageHubBuilder {
+ typedef RegisterMessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hub(flatbuffers::Offset<chre::fbs::MessageHub> hub) {
+ fbb_.AddOffset(RegisterMessageHub::VT_HUB, hub);
+ }
+ explicit RegisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ RegisterMessageHubBuilder &operator=(const RegisterMessageHubBuilder &);
+ flatbuffers::Offset<RegisterMessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<RegisterMessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<RegisterMessageHub> CreateRegisterMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::MessageHub> hub = 0) {
+ RegisterMessageHubBuilder builder_(_fbb);
+ builder_.add_hub(hub);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<RegisterMessageHub> CreateRegisterMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const RegisterMessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct UnregisterMessageHubT : public flatbuffers::NativeTable {
+ typedef UnregisterMessageHub TableType;
+ int64_t id;
+ UnregisterMessageHubT()
+ : id(0) {
+ }
+};
+
+struct UnregisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef UnregisterMessageHubT NativeTableType;
+ typedef UnregisterMessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4
+ };
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ bool mutate_id(int64_t _id) {
+ return SetField<int64_t>(VT_ID, _id, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+ UnregisterMessageHubT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(UnregisterMessageHubT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<UnregisterMessageHub> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterMessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct UnregisterMessageHubBuilder {
+ typedef UnregisterMessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(UnregisterMessageHub::VT_ID, id, 0);
+ }
+ explicit UnregisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ UnregisterMessageHubBuilder &operator=(const UnregisterMessageHubBuilder &);
+ flatbuffers::Offset<UnregisterMessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<UnregisterMessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<UnregisterMessageHub> CreateUnregisterMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0) {
+ UnregisterMessageHubBuilder builder_(_fbb);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<UnregisterMessageHub> CreateUnregisterMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterMessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointIdT : public flatbuffers::NativeTable {
+ typedef EndpointId TableType;
+ int64_t hubId;
+ int64_t id;
+ EndpointIdT()
+ : hubId(0),
+ id(0) {
+ }
+};
+
+struct EndpointId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointIdT NativeTableType;
+ typedef EndpointIdBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUBID = 4,
+ VT_ID = 6
+ };
+ /// Id of the hub hosting the endpoint
+ int64_t hubId() const {
+ return GetField<int64_t>(VT_HUBID, 0);
+ }
+ bool mutate_hubId(int64_t _hubId) {
+ return SetField<int64_t>(VT_HUBID, _hubId, 0);
+ }
+ /// The id of the endpoint scoped to the hub
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ bool mutate_id(int64_t _id) {
+ return SetField<int64_t>(VT_ID, _id, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_HUBID) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+ EndpointIdT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointIdT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointId> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointIdT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointIdBuilder {
+ typedef EndpointId Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hubId(int64_t hubId) {
+ fbb_.AddElement<int64_t>(EndpointId::VT_HUBID, hubId, 0);
+ }
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(EndpointId::VT_ID, id, 0);
+ }
+ explicit EndpointIdBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointIdBuilder &operator=(const EndpointIdBuilder &);
+ flatbuffers::Offset<EndpointId> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointId>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointId> CreateEndpointId(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t hubId = 0,
+ int64_t id = 0) {
+ EndpointIdBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_hubId(hubId);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<EndpointId> CreateEndpointId(flatbuffers::FlatBufferBuilder &_fbb, const EndpointIdT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ServiceT : public flatbuffers::NativeTable {
+ typedef Service TableType;
+ chre::fbs::RpcFormat format;
+ std::vector<int8_t> descriptor;
+ uint32_t major_version;
+ uint32_t minor_version;
+ ServiceT()
+ : format(chre::fbs::RpcFormat::CUSTOM),
+ major_version(0),
+ minor_version(0) {
+ }
+};
+
+struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef ServiceT NativeTableType;
+ typedef ServiceBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_FORMAT = 4,
+ VT_DESCRIPTOR = 6,
+ VT_MAJOR_VERSION = 8,
+ VT_MINOR_VERSION = 10
+ };
+ chre::fbs::RpcFormat format() const {
+ return static_cast<chre::fbs::RpcFormat>(GetField<uint8_t>(VT_FORMAT, 0));
+ }
+ bool mutate_format(chre::fbs::RpcFormat _format) {
+ return SetField<uint8_t>(VT_FORMAT, static_cast<uint8_t>(_format), 0);
+ }
+ /// Service descriptor. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *descriptor() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DESCRIPTOR);
+ }
+ flatbuffers::Vector<int8_t> *mutable_descriptor() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_DESCRIPTOR);
+ }
+ /// Breaking changes should bump the major version.
+ uint32_t major_version() const {
+ return GetField<uint32_t>(VT_MAJOR_VERSION, 0);
+ }
+ bool mutate_major_version(uint32_t _major_version) {
+ return SetField<uint32_t>(VT_MAJOR_VERSION, _major_version, 0);
+ }
+ /// Monotonically increasing minor version.
+ uint32_t minor_version() const {
+ return GetField<uint32_t>(VT_MINOR_VERSION, 0);
+ }
+ bool mutate_minor_version(uint32_t _minor_version) {
+ return SetField<uint32_t>(VT_MINOR_VERSION, _minor_version, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint8_t>(verifier, VT_FORMAT) &&
+ VerifyOffset(verifier, VT_DESCRIPTOR) &&
+ verifier.VerifyVector(descriptor()) &&
+ VerifyField<uint32_t>(verifier, VT_MAJOR_VERSION) &&
+ VerifyField<uint32_t>(verifier, VT_MINOR_VERSION) &&
+ verifier.EndTable();
+ }
+ ServiceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(ServiceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Service> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct ServiceBuilder {
+ typedef Service Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_format(chre::fbs::RpcFormat format) {
+ fbb_.AddElement<uint8_t>(Service::VT_FORMAT, static_cast<uint8_t>(format), 0);
+ }
+ void add_descriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor) {
+ fbb_.AddOffset(Service::VT_DESCRIPTOR, descriptor);
+ }
+ void add_major_version(uint32_t major_version) {
+ fbb_.AddElement<uint32_t>(Service::VT_MAJOR_VERSION, major_version, 0);
+ }
+ void add_minor_version(uint32_t minor_version) {
+ fbb_.AddElement<uint32_t>(Service::VT_MINOR_VERSION, minor_version, 0);
+ }
+ explicit ServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ ServiceBuilder &operator=(const ServiceBuilder &);
+ flatbuffers::Offset<Service> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<Service>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<Service> CreateService(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor = 0,
+ uint32_t major_version = 0,
+ uint32_t minor_version = 0) {
+ ServiceBuilder builder_(_fbb);
+ builder_.add_minor_version(minor_version);
+ builder_.add_major_version(major_version);
+ builder_.add_descriptor(descriptor);
+ builder_.add_format(format);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Service> CreateServiceDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
+ const std::vector<int8_t> *descriptor = nullptr,
+ uint32_t major_version = 0,
+ uint32_t minor_version = 0) {
+ auto descriptor__ = descriptor ? _fbb.CreateVector<int8_t>(*descriptor) : 0;
+ return chre::fbs::CreateService(
+ _fbb,
+ format,
+ descriptor__,
+ major_version,
+ minor_version);
+}
+
+flatbuffers::Offset<Service> CreateService(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointInfoT : public flatbuffers::NativeTable {
+ typedef EndpointInfo TableType;
+ std::unique_ptr<chre::fbs::EndpointIdT> id;
+ chre::fbs::EndpointType type;
+ std::vector<int8_t> name;
+ uint32_t version;
+ uint32_t required_permissions;
+ std::vector<std::unique_ptr<chre::fbs::ServiceT>> services;
+ EndpointInfoT()
+ : type(chre::fbs::EndpointType::INVALID),
+ version(0),
+ required_permissions(0) {
+ }
+};
+
+struct EndpointInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointInfoT NativeTableType;
+ typedef EndpointInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_TYPE = 6,
+ VT_NAME = 8,
+ VT_VERSION = 10,
+ VT_REQUIRED_PERMISSIONS = 12,
+ VT_SERVICES = 14
+ };
+ const chre::fbs::EndpointId *id() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_ID);
+ }
+ chre::fbs::EndpointId *mutable_id() {
+ return GetPointer<chre::fbs::EndpointId *>(VT_ID);
+ }
+ chre::fbs::EndpointType type() const {
+ return static_cast<chre::fbs::EndpointType>(GetField<uint8_t>(VT_TYPE, 0));
+ }
+ bool mutate_type(chre::fbs::EndpointType _type) {
+ return SetField<uint8_t>(VT_TYPE, static_cast<uint8_t>(_type), 0);
+ }
+ /// Endpoing name. Nominally a UTF-8 string, but note that we're not using
+ /// the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ flatbuffers::Vector<int8_t> *mutable_name() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ uint32_t version() const {
+ return GetField<uint32_t>(VT_VERSION, 0);
+ }
+ bool mutate_version(uint32_t _version) {
+ return SetField<uint32_t>(VT_VERSION, _version, 0);
+ }
+ /// Values from CHRE_MESSAGE_PERMISSION_*
+ uint32_t required_permissions() const {
+ return GetField<uint32_t>(VT_REQUIRED_PERMISSIONS, 0);
+ }
+ bool mutate_required_permissions(uint32_t _required_permissions) {
+ return SetField<uint32_t>(VT_REQUIRED_PERMISSIONS, _required_permissions, 0);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *services() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *>(VT_SERVICES);
+ }
+ flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *mutable_services() {
+ return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *>(VT_SERVICES);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ID) &&
+ verifier.VerifyTable(id()) &&
+ VerifyField<uint8_t>(verifier, VT_TYPE) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<uint32_t>(verifier, VT_VERSION) &&
+ VerifyField<uint32_t>(verifier, VT_REQUIRED_PERMISSIONS) &&
+ VerifyOffset(verifier, VT_SERVICES) &&
+ verifier.VerifyVector(services()) &&
+ verifier.VerifyVectorOfTables(services()) &&
+ verifier.EndTable();
+ }
+ EndpointInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointInfo> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointInfoBuilder {
+ typedef EndpointInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(flatbuffers::Offset<chre::fbs::EndpointId> id) {
+ fbb_.AddOffset(EndpointInfo::VT_ID, id);
+ }
+ void add_type(chre::fbs::EndpointType type) {
+ fbb_.AddElement<uint8_t>(EndpointInfo::VT_TYPE, static_cast<uint8_t>(type), 0);
+ }
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(EndpointInfo::VT_NAME, name);
+ }
+ void add_version(uint32_t version) {
+ fbb_.AddElement<uint32_t>(EndpointInfo::VT_VERSION, version, 0);
+ }
+ void add_required_permissions(uint32_t required_permissions) {
+ fbb_.AddElement<uint32_t>(EndpointInfo::VT_REQUIRED_PERMISSIONS, required_permissions, 0);
+ }
+ void add_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services) {
+ fbb_.AddOffset(EndpointInfo::VT_SERVICES, services);
+ }
+ explicit EndpointInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointInfoBuilder &operator=(const EndpointInfoBuilder &);
+ flatbuffers::Offset<EndpointInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
+ chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ uint32_t version = 0,
+ uint32_t required_permissions = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services = 0) {
+ EndpointInfoBuilder builder_(_fbb);
+ builder_.add_services(services);
+ builder_.add_required_permissions(required_permissions);
+ builder_.add_version(version);
+ builder_.add_name(name);
+ builder_.add_id(id);
+ builder_.add_type(type);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
+ chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
+ const std::vector<int8_t> *name = nullptr,
+ uint32_t version = 0,
+ uint32_t required_permissions = 0,
+ const std::vector<flatbuffers::Offset<chre::fbs::Service>> *services = nullptr) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ auto services__ = services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::Service>>(*services) : 0;
+ return chre::fbs::CreateEndpointInfo(
+ _fbb,
+ id,
+ type,
+ name__,
+ version,
+ required_permissions,
+ services__);
+}
+
+flatbuffers::Offset<EndpointInfo> CreateEndpointInfo(flatbuffers::FlatBufferBuilder &_fbb, const EndpointInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RegisterEndpointT : public flatbuffers::NativeTable {
+ typedef RegisterEndpoint TableType;
+ std::unique_ptr<chre::fbs::EndpointInfoT> endpoint;
+ RegisterEndpointT() {
+ }
+};
+
+struct RegisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef RegisterEndpointT NativeTableType;
+ typedef RegisterEndpointBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ENDPOINT = 4
+ };
+ const chre::fbs::EndpointInfo *endpoint() const {
+ return GetPointer<const chre::fbs::EndpointInfo *>(VT_ENDPOINT);
+ }
+ chre::fbs::EndpointInfo *mutable_endpoint() {
+ return GetPointer<chre::fbs::EndpointInfo *>(VT_ENDPOINT);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ENDPOINT) &&
+ verifier.VerifyTable(endpoint()) &&
+ verifier.EndTable();
+ }
+ RegisterEndpointT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(RegisterEndpointT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<RegisterEndpoint> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegisterEndpointT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RegisterEndpointBuilder {
+ typedef RegisterEndpoint Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint) {
+ fbb_.AddOffset(RegisterEndpoint::VT_ENDPOINT, endpoint);
+ }
+ explicit RegisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ RegisterEndpointBuilder &operator=(const RegisterEndpointBuilder &);
+ flatbuffers::Offset<RegisterEndpoint> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<RegisterEndpoint>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<RegisterEndpoint> CreateRegisterEndpoint(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint = 0) {
+ RegisterEndpointBuilder builder_(_fbb);
+ builder_.add_endpoint(endpoint);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<RegisterEndpoint> CreateRegisterEndpoint(flatbuffers::FlatBufferBuilder &_fbb, const RegisterEndpointT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct UnregisterEndpointT : public flatbuffers::NativeTable {
+ typedef UnregisterEndpoint TableType;
+ std::unique_ptr<chre::fbs::EndpointIdT> endpoint;
+ UnregisterEndpointT() {
+ }
+};
+
+struct UnregisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef UnregisterEndpointT NativeTableType;
+ typedef UnregisterEndpointBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ENDPOINT = 4
+ };
+ const chre::fbs::EndpointId *endpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_ENDPOINT);
+ }
+ chre::fbs::EndpointId *mutable_endpoint() {
+ return GetPointer<chre::fbs::EndpointId *>(VT_ENDPOINT);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ENDPOINT) &&
+ verifier.VerifyTable(endpoint()) &&
+ verifier.EndTable();
+ }
+ UnregisterEndpointT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(UnregisterEndpointT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<UnregisterEndpoint> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterEndpointT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct UnregisterEndpointBuilder {
+ typedef UnregisterEndpoint Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointId> endpoint) {
+ fbb_.AddOffset(UnregisterEndpoint::VT_ENDPOINT, endpoint);
+ }
+ explicit UnregisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ UnregisterEndpointBuilder &operator=(const UnregisterEndpointBuilder &);
+ flatbuffers::Offset<UnregisterEndpoint> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<UnregisterEndpoint>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<UnregisterEndpoint> CreateUnregisterEndpoint(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> endpoint = 0) {
+ UnregisterEndpointBuilder builder_(_fbb);
+ builder_.add_endpoint(endpoint);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<UnregisterEndpoint> CreateUnregisterEndpoint(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterEndpointT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct GetMessageHubsAndEndpointsRequestT : public flatbuffers::NativeTable {
+ typedef GetMessageHubsAndEndpointsRequest TableType;
+ GetMessageHubsAndEndpointsRequestT() {
+ }
+};
+
+/// HAL->CHRE, indicates the HAL is coming up
+struct GetMessageHubsAndEndpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef GetMessageHubsAndEndpointsRequestT NativeTableType;
+ typedef GetMessageHubsAndEndpointsRequestBuilder Builder;
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ verifier.EndTable();
+ }
+ GetMessageHubsAndEndpointsRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(GetMessageHubsAndEndpointsRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct GetMessageHubsAndEndpointsRequestBuilder {
+ typedef GetMessageHubsAndEndpointsRequest Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ explicit GetMessageHubsAndEndpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ GetMessageHubsAndEndpointsRequestBuilder &operator=(const GetMessageHubsAndEndpointsRequestBuilder &);
+ flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> CreateGetMessageHubsAndEndpointsRequest(
+ flatbuffers::FlatBufferBuilder &_fbb) {
+ GetMessageHubsAndEndpointsRequestBuilder builder_(_fbb);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> CreateGetMessageHubsAndEndpointsRequest(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct GetMessageHubsAndEndpointsResponseT : public flatbuffers::NativeTable {
+ typedef GetMessageHubsAndEndpointsResponse TableType;
+ std::vector<std::unique_ptr<chre::fbs::MessageHubT>> hubs;
+ std::vector<std::unique_ptr<chre::fbs::EndpointInfoT>> endpoints;
+ GetMessageHubsAndEndpointsResponseT() {
+ }
+};
+
+struct GetMessageHubsAndEndpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef GetMessageHubsAndEndpointsResponseT NativeTableType;
+ typedef GetMessageHubsAndEndpointsResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUBS = 4,
+ VT_ENDPOINTS = 6
+ };
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *>(VT_HUBS);
+ }
+ flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *mutable_hubs() {
+ return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *>(VT_HUBS);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *>(VT_ENDPOINTS);
+ }
+ flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *mutable_endpoints() {
+ return GetPointer<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *>(VT_ENDPOINTS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_HUBS) &&
+ verifier.VerifyVector(hubs()) &&
+ verifier.VerifyVectorOfTables(hubs()) &&
+ VerifyOffset(verifier, VT_ENDPOINTS) &&
+ verifier.VerifyVector(endpoints()) &&
+ verifier.VerifyVectorOfTables(endpoints()) &&
+ verifier.EndTable();
+ }
+ GetMessageHubsAndEndpointsResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(GetMessageHubsAndEndpointsResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct GetMessageHubsAndEndpointsResponseBuilder {
+ typedef GetMessageHubsAndEndpointsResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hubs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs) {
+ fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_HUBS, hubs);
+ }
+ void add_endpoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints) {
+ fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_ENDPOINTS, endpoints);
+ }
+ explicit GetMessageHubsAndEndpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ GetMessageHubsAndEndpointsResponseBuilder &operator=(const GetMessageHubsAndEndpointsResponseBuilder &);
+ flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints = 0) {
+ GetMessageHubsAndEndpointsResponseBuilder builder_(_fbb);
+ builder_.add_endpoints(endpoints);
+ builder_.add_hubs(hubs);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs = nullptr,
+ const std::vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints = nullptr) {
+ auto hubs__ = hubs ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MessageHub>>(*hubs) : 0;
+ auto endpoints__ = endpoints ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::EndpointInfo>>(*endpoints) : 0;
+ return chre::fbs::CreateGetMessageHubsAndEndpointsResponse(
+ _fbb,
+ hubs__,
+ endpoints__);
+}
+
+flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponse(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct OpenEndpointSessionRequestT : public flatbuffers::NativeTable {
+ typedef OpenEndpointSessionRequest TableType;
+ uint16_t id;
+ std::unique_ptr<chre::fbs::EndpointIdT> fromEndpoint;
+ std::unique_ptr<chre::fbs::EndpointIdT> toEndpoint;
+ std::vector<int8_t> serviceDescriptor;
+ OpenEndpointSessionRequestT()
+ : id(0) {
+ }
+};
+
+struct OpenEndpointSessionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef OpenEndpointSessionRequestT NativeTableType;
+ typedef OpenEndpointSessionRequestBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_FROMENDPOINT = 6,
+ VT_TOENDPOINT = 8,
+ VT_SERVICEDESCRIPTOR = 10
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ bool mutate_id(uint16_t _id) {
+ return SetField<uint16_t>(VT_ID, _id, 0);
+ }
+ const chre::fbs::EndpointId *fromEndpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_FROMENDPOINT);
+ }
+ chre::fbs::EndpointId *mutable_fromEndpoint() {
+ return GetPointer<chre::fbs::EndpointId *>(VT_FROMENDPOINT);
+ }
+ const chre::fbs::EndpointId *toEndpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_TOENDPOINT);
+ }
+ chre::fbs::EndpointId *mutable_toEndpoint() {
+ return GetPointer<chre::fbs::EndpointId *>(VT_TOENDPOINT);
+ }
+ /// If present, describes the service definition used over the session
+ const flatbuffers::Vector<int8_t> *serviceDescriptor() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_SERVICEDESCRIPTOR);
+ }
+ flatbuffers::Vector<int8_t> *mutable_serviceDescriptor() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_SERVICEDESCRIPTOR);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ VerifyOffset(verifier, VT_FROMENDPOINT) &&
+ verifier.VerifyTable(fromEndpoint()) &&
+ VerifyOffset(verifier, VT_TOENDPOINT) &&
+ verifier.VerifyTable(toEndpoint()) &&
+ VerifyOffset(verifier, VT_SERVICEDESCRIPTOR) &&
+ verifier.VerifyVector(serviceDescriptor()) &&
+ verifier.EndTable();
+ }
+ OpenEndpointSessionRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(OpenEndpointSessionRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<OpenEndpointSessionRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OpenEndpointSessionRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct OpenEndpointSessionRequestBuilder {
+ typedef OpenEndpointSessionRequest Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(OpenEndpointSessionRequest::VT_ID, id, 0);
+ }
+ void add_fromEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_FROMENDPOINT, fromEndpoint);
+ }
+ void add_toEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_TOENDPOINT, toEndpoint);
+ }
+ void add_serviceDescriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_SERVICEDESCRIPTOR, serviceDescriptor);
+ }
+ explicit OpenEndpointSessionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ OpenEndpointSessionRequestBuilder &operator=(const OpenEndpointSessionRequestBuilder &);
+ flatbuffers::Offset<OpenEndpointSessionRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<OpenEndpointSessionRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequest(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor = 0) {
+ OpenEndpointSessionRequestBuilder builder_(_fbb);
+ builder_.add_serviceDescriptor(serviceDescriptor);
+ builder_.add_toEndpoint(toEndpoint);
+ builder_.add_fromEndpoint(fromEndpoint);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequestDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
+ const std::vector<int8_t> *serviceDescriptor = nullptr) {
+ auto serviceDescriptor__ = serviceDescriptor ? _fbb.CreateVector<int8_t>(*serviceDescriptor) : 0;
+ return chre::fbs::CreateOpenEndpointSessionRequest(
+ _fbb,
+ id,
+ fromEndpoint,
+ toEndpoint,
+ serviceDescriptor__);
+}
+
+flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequest(flatbuffers::FlatBufferBuilder &_fbb, const OpenEndpointSessionRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointSessionOpenedT : public flatbuffers::NativeTable {
+ typedef EndpointSessionOpened TableType;
+ uint16_t id;
+ EndpointSessionOpenedT()
+ : id(0) {
+ }
+};
+
+struct EndpointSessionOpened FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionOpenedT NativeTableType;
+ typedef EndpointSessionOpenedBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ bool mutate_id(uint16_t _id) {
+ return SetField<uint16_t>(VT_ID, _id, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+ EndpointSessionOpenedT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointSessionOpenedT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointSessionOpened> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionOpenedT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointSessionOpenedBuilder {
+ typedef EndpointSessionOpened Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionOpened::VT_ID, id, 0);
+ }
+ explicit EndpointSessionOpenedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionOpenedBuilder &operator=(const EndpointSessionOpenedBuilder &);
+ flatbuffers::Offset<EndpointSessionOpened> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionOpened>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionOpened> CreateEndpointSessionOpened(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0) {
+ EndpointSessionOpenedBuilder builder_(_fbb);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<EndpointSessionOpened> CreateEndpointSessionOpened(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionOpenedT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointSessionClosedT : public flatbuffers::NativeTable {
+ typedef EndpointSessionClosed TableType;
+ uint16_t id;
+ chre::fbs::Reason reason;
+ EndpointSessionClosedT()
+ : id(0),
+ reason(chre::fbs::Reason::UNSPECIFIED) {
+ }
+};
+
+struct EndpointSessionClosed FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionClosedT NativeTableType;
+ typedef EndpointSessionClosedBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_REASON = 6
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ bool mutate_id(uint16_t _id) {
+ return SetField<uint16_t>(VT_ID, _id, 0);
+ }
+ chre::fbs::Reason reason() const {
+ return static_cast<chre::fbs::Reason>(GetField<uint8_t>(VT_REASON, 0));
+ }
+ bool mutate_reason(chre::fbs::Reason _reason) {
+ return SetField<uint8_t>(VT_REASON, static_cast<uint8_t>(_reason), 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ VerifyField<uint8_t>(verifier, VT_REASON) &&
+ verifier.EndTable();
+ }
+ EndpointSessionClosedT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointSessionClosedT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointSessionClosed> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionClosedT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointSessionClosedBuilder {
+ typedef EndpointSessionClosed Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionClosed::VT_ID, id, 0);
+ }
+ void add_reason(chre::fbs::Reason reason) {
+ fbb_.AddElement<uint8_t>(EndpointSessionClosed::VT_REASON, static_cast<uint8_t>(reason), 0);
+ }
+ explicit EndpointSessionClosedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionClosedBuilder &operator=(const EndpointSessionClosedBuilder &);
+ flatbuffers::Offset<EndpointSessionClosed> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionClosed>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionClosed> CreateEndpointSessionClosed(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ chre::fbs::Reason reason = chre::fbs::Reason::UNSPECIFIED) {
+ EndpointSessionClosedBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_reason(reason);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<EndpointSessionClosed> CreateEndpointSessionClosed(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionClosedT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointSessionMessageT : public flatbuffers::NativeTable {
+ typedef EndpointSessionMessage TableType;
+ uint16_t session_id;
+ uint32_t type;
+ uint32_t permissions;
+ std::vector<uint8_t> data;
+ uint32_t flags;
+ uint32_t sequence_number;
+ EndpointSessionMessageT()
+ : session_id(0),
+ type(0),
+ permissions(0),
+ flags(0),
+ sequence_number(0) {
+ }
+};
+
+struct EndpointSessionMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionMessageT NativeTableType;
+ typedef EndpointSessionMessageBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SESSION_ID = 4,
+ VT_TYPE = 6,
+ VT_PERMISSIONS = 8,
+ VT_DATA = 10,
+ VT_FLAGS = 12,
+ VT_SEQUENCE_NUMBER = 14
+ };
+ /// Id of session this message is being sent within
+ uint16_t session_id() const {
+ return GetField<uint16_t>(VT_SESSION_ID, 0);
+ }
+ bool mutate_session_id(uint16_t _session_id) {
+ return SetField<uint16_t>(VT_SESSION_ID, _session_id, 0);
+ }
+ /// Type of the message, specific to the Session protocol
+ uint32_t type() const {
+ return GetField<uint32_t>(VT_TYPE, 0);
+ }
+ bool mutate_type(uint32_t _type) {
+ return SetField<uint32_t>(VT_TYPE, _type, 0);
+ }
+ /// Values from CHRE_MESSAGE_PERMISSION_*. Permissions required to read the
+ /// message.
+ uint32_t permissions() const {
+ return GetField<uint32_t>(VT_PERMISSIONS, 0);
+ }
+ bool mutate_permissions(uint32_t _permissions) {
+ return SetField<uint32_t>(VT_PERMISSIONS, _permissions, 0);
+ }
+ const flatbuffers::Vector<uint8_t> *data() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ }
+ flatbuffers::Vector<uint8_t> *mutable_data() {
+ return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ }
+ /// Bitmask of additional flags applied to the message:
+ /// - 0x1: Message delivery status required within 1s
+ uint32_t flags() const {
+ return GetField<uint32_t>(VT_FLAGS, 0);
+ }
+ bool mutate_flags(uint32_t _flags) {
+ return SetField<uint32_t>(VT_FLAGS, _flags, 0);
+ }
+ uint32_t sequence_number() const {
+ return GetField<uint32_t>(VT_SEQUENCE_NUMBER, 0);
+ }
+ bool mutate_sequence_number(uint32_t _sequence_number) {
+ return SetField<uint32_t>(VT_SEQUENCE_NUMBER, _sequence_number, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
+ VerifyField<uint32_t>(verifier, VT_TYPE) &&
+ VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
+ VerifyOffset(verifier, VT_DATA) &&
+ verifier.VerifyVector(data()) &&
+ VerifyField<uint32_t>(verifier, VT_FLAGS) &&
+ VerifyField<uint32_t>(verifier, VT_SEQUENCE_NUMBER) &&
+ verifier.EndTable();
+ }
+ EndpointSessionMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointSessionMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointSessionMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointSessionMessageBuilder {
+ typedef EndpointSessionMessage Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_session_id(uint16_t session_id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionMessage::VT_SESSION_ID, session_id, 0);
+ }
+ void add_type(uint32_t type) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_TYPE, type, 0);
+ }
+ void add_permissions(uint32_t permissions) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_PERMISSIONS, permissions, 0);
+ }
+ void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
+ fbb_.AddOffset(EndpointSessionMessage::VT_DATA, data);
+ }
+ void add_flags(uint32_t flags) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_FLAGS, flags, 0);
+ }
+ void add_sequence_number(uint32_t sequence_number) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_SEQUENCE_NUMBER, sequence_number, 0);
+ }
+ explicit EndpointSessionMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionMessageBuilder &operator=(const EndpointSessionMessageBuilder &);
+ flatbuffers::Offset<EndpointSessionMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessage(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ uint32_t type = 0,
+ uint32_t permissions = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
+ uint32_t flags = 0,
+ uint32_t sequence_number = 0) {
+ EndpointSessionMessageBuilder builder_(_fbb);
+ builder_.add_sequence_number(sequence_number);
+ builder_.add_flags(flags);
+ builder_.add_data(data);
+ builder_.add_permissions(permissions);
+ builder_.add_type(type);
+ builder_.add_session_id(session_id);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessageDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ uint32_t type = 0,
+ uint32_t permissions = 0,
+ const std::vector<uint8_t> *data = nullptr,
+ uint32_t flags = 0,
+ uint32_t sequence_number = 0) {
+ auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+ return chre::fbs::CreateEndpointSessionMessage(
+ _fbb,
+ session_id,
+ type,
+ permissions,
+ data__,
+ flags,
+ sequence_number);
+}
+
+flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessage(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EndpointSessionMessageDeliveryStatusT : public flatbuffers::NativeTable {
+ typedef EndpointSessionMessageDeliveryStatus TableType;
+ uint16_t session_id;
+ std::unique_ptr<chre::fbs::MessageDeliveryStatusT> status;
+ EndpointSessionMessageDeliveryStatusT()
+ : session_id(0) {
+ }
+};
+
+struct EndpointSessionMessageDeliveryStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionMessageDeliveryStatusT NativeTableType;
+ typedef EndpointSessionMessageDeliveryStatusBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SESSION_ID = 4,
+ VT_STATUS = 6
+ };
+ /// Id of session the message was sent within
+ uint16_t session_id() const {
+ return GetField<uint16_t>(VT_SESSION_ID, 0);
+ }
+ bool mutate_session_id(uint16_t _session_id) {
+ return SetField<uint16_t>(VT_SESSION_ID, _session_id, 0);
+ }
+ const chre::fbs::MessageDeliveryStatus *status() const {
+ return GetPointer<const chre::fbs::MessageDeliveryStatus *>(VT_STATUS);
+ }
+ chre::fbs::MessageDeliveryStatus *mutable_status() {
+ return GetPointer<chre::fbs::MessageDeliveryStatus *>(VT_STATUS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
+ VerifyOffset(verifier, VT_STATUS) &&
+ verifier.VerifyTable(status()) &&
+ verifier.EndTable();
+ }
+ EndpointSessionMessageDeliveryStatusT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EndpointSessionMessageDeliveryStatusT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageDeliveryStatusT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct EndpointSessionMessageDeliveryStatusBuilder {
+ typedef EndpointSessionMessageDeliveryStatus Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_session_id(uint16_t session_id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionMessageDeliveryStatus::VT_SESSION_ID, session_id, 0);
+ }
+ void add_status(flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status) {
+ fbb_.AddOffset(EndpointSessionMessageDeliveryStatus::VT_STATUS, status);
+ }
+ explicit EndpointSessionMessageDeliveryStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionMessageDeliveryStatusBuilder &operator=(const EndpointSessionMessageDeliveryStatusBuilder &);
+ flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionMessageDeliveryStatus>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> CreateEndpointSessionMessageDeliveryStatus(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status = 0) {
+ EndpointSessionMessageDeliveryStatusBuilder builder_(_fbb);
+ builder_.add_status(status);
+ builder_.add_session_id(session_id);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> CreateEndpointSessionMessageDeliveryStatus(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageDeliveryStatusT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
struct MessageContainerT : public flatbuffers::NativeTable {
typedef MessageContainer TableType;
chre::fbs::ChreMessageUnion message;
@@ -4010,6 +6696,51 @@
const chre::fbs::MessageDeliveryStatus *message_as_MessageDeliveryStatus() const {
return message_type() == chre::fbs::ChreMessage::MessageDeliveryStatus ? static_cast<const chre::fbs::MessageDeliveryStatus *>(message()) : nullptr;
}
+ const chre::fbs::BtSocketOpen *message_as_BtSocketOpen() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketOpen ? static_cast<const chre::fbs::BtSocketOpen *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketOpenResponse *message_as_BtSocketOpenResponse() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketOpenResponse ? static_cast<const chre::fbs::BtSocketOpenResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketClose *message_as_BtSocketClose() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketClose ? static_cast<const chre::fbs::BtSocketClose *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketCloseResponse *message_as_BtSocketCloseResponse() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketCloseResponse ? static_cast<const chre::fbs::BtSocketCloseResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsRequest *message_as_GetMessageHubsAndEndpointsRequest() const {
+ return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsRequest ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(message()) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsResponse *message_as_GetMessageHubsAndEndpointsResponse() const {
+ return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsResponse ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::RegisterMessageHub *message_as_RegisterMessageHub() const {
+ return message_type() == chre::fbs::ChreMessage::RegisterMessageHub ? static_cast<const chre::fbs::RegisterMessageHub *>(message()) : nullptr;
+ }
+ const chre::fbs::UnregisterMessageHub *message_as_UnregisterMessageHub() const {
+ return message_type() == chre::fbs::ChreMessage::UnregisterMessageHub ? static_cast<const chre::fbs::UnregisterMessageHub *>(message()) : nullptr;
+ }
+ const chre::fbs::RegisterEndpoint *message_as_RegisterEndpoint() const {
+ return message_type() == chre::fbs::ChreMessage::RegisterEndpoint ? static_cast<const chre::fbs::RegisterEndpoint *>(message()) : nullptr;
+ }
+ const chre::fbs::UnregisterEndpoint *message_as_UnregisterEndpoint() const {
+ return message_type() == chre::fbs::ChreMessage::UnregisterEndpoint ? static_cast<const chre::fbs::UnregisterEndpoint *>(message()) : nullptr;
+ }
+ const chre::fbs::OpenEndpointSessionRequest *message_as_OpenEndpointSessionRequest() const {
+ return message_type() == chre::fbs::ChreMessage::OpenEndpointSessionRequest ? static_cast<const chre::fbs::OpenEndpointSessionRequest *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionOpened *message_as_EndpointSessionOpened() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionOpened ? static_cast<const chre::fbs::EndpointSessionOpened *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionClosed *message_as_EndpointSessionClosed() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionClosed ? static_cast<const chre::fbs::EndpointSessionClosed *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessage *message_as_EndpointSessionMessage() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionMessage ? static_cast<const chre::fbs::EndpointSessionMessage *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessageDeliveryStatus *message_as_EndpointSessionMessageDeliveryStatus() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionMessageDeliveryStatus ? static_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(message()) : nullptr;
+ }
void *mutable_message() {
return GetPointer<void *>(VT_MESSAGE);
}
@@ -4166,6 +6897,66 @@
return message_as_MessageDeliveryStatus();
}
+template<> inline const chre::fbs::BtSocketOpen *MessageContainer::message_as<chre::fbs::BtSocketOpen>() const {
+ return message_as_BtSocketOpen();
+}
+
+template<> inline const chre::fbs::BtSocketOpenResponse *MessageContainer::message_as<chre::fbs::BtSocketOpenResponse>() const {
+ return message_as_BtSocketOpenResponse();
+}
+
+template<> inline const chre::fbs::BtSocketClose *MessageContainer::message_as<chre::fbs::BtSocketClose>() const {
+ return message_as_BtSocketClose();
+}
+
+template<> inline const chre::fbs::BtSocketCloseResponse *MessageContainer::message_as<chre::fbs::BtSocketCloseResponse>() const {
+ return message_as_BtSocketCloseResponse();
+}
+
+template<> inline const chre::fbs::GetMessageHubsAndEndpointsRequest *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsRequest>() const {
+ return message_as_GetMessageHubsAndEndpointsRequest();
+}
+
+template<> inline const chre::fbs::GetMessageHubsAndEndpointsResponse *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsResponse>() const {
+ return message_as_GetMessageHubsAndEndpointsResponse();
+}
+
+template<> inline const chre::fbs::RegisterMessageHub *MessageContainer::message_as<chre::fbs::RegisterMessageHub>() const {
+ return message_as_RegisterMessageHub();
+}
+
+template<> inline const chre::fbs::UnregisterMessageHub *MessageContainer::message_as<chre::fbs::UnregisterMessageHub>() const {
+ return message_as_UnregisterMessageHub();
+}
+
+template<> inline const chre::fbs::RegisterEndpoint *MessageContainer::message_as<chre::fbs::RegisterEndpoint>() const {
+ return message_as_RegisterEndpoint();
+}
+
+template<> inline const chre::fbs::UnregisterEndpoint *MessageContainer::message_as<chre::fbs::UnregisterEndpoint>() const {
+ return message_as_UnregisterEndpoint();
+}
+
+template<> inline const chre::fbs::OpenEndpointSessionRequest *MessageContainer::message_as<chre::fbs::OpenEndpointSessionRequest>() const {
+ return message_as_OpenEndpointSessionRequest();
+}
+
+template<> inline const chre::fbs::EndpointSessionOpened *MessageContainer::message_as<chre::fbs::EndpointSessionOpened>() const {
+ return message_as_EndpointSessionOpened();
+}
+
+template<> inline const chre::fbs::EndpointSessionClosed *MessageContainer::message_as<chre::fbs::EndpointSessionClosed>() const {
+ return message_as_EndpointSessionClosed();
+}
+
+template<> inline const chre::fbs::EndpointSessionMessage *MessageContainer::message_as<chre::fbs::EndpointSessionMessage>() const {
+ return message_as_EndpointSessionMessage();
+}
+
+template<> inline const chre::fbs::EndpointSessionMessageDeliveryStatus *MessageContainer::message_as<chre::fbs::EndpointSessionMessageDeliveryStatus>() const {
+ return message_as_EndpointSessionMessageDeliveryStatus();
+}
+
struct MessageContainerBuilder {
typedef MessageContainer Table;
flatbuffers::FlatBufferBuilder &fbb_;
@@ -5217,6 +8008,672 @@
_fbb);
}
+inline LeCocChannelInfoT *LeCocChannelInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::LeCocChannelInfoT> _o = std::unique_ptr<chre::fbs::LeCocChannelInfoT>(new LeCocChannelInfoT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void LeCocChannelInfo::UnPackTo(LeCocChannelInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = localCid(); _o->localCid = _e; }
+ { auto _e = remoteCid(); _o->remoteCid = _e; }
+ { auto _e = psm(); _o->psm = _e; }
+ { auto _e = localMtu(); _o->localMtu = _e; }
+ { auto _e = remoteMtu(); _o->remoteMtu = _e; }
+ { auto _e = localMps(); _o->localMps = _e; }
+ { auto _e = remoteMps(); _o->remoteMps = _e; }
+ { auto _e = initialRxCredits(); _o->initialRxCredits = _e; }
+ { auto _e = initialTxCredits(); _o->initialTxCredits = _e; }
+}
+
+inline flatbuffers::Offset<LeCocChannelInfo> LeCocChannelInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeCocChannelInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateLeCocChannelInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<LeCocChannelInfo> CreateLeCocChannelInfo(flatbuffers::FlatBufferBuilder &_fbb, const LeCocChannelInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeCocChannelInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _localCid = _o->localCid;
+ auto _remoteCid = _o->remoteCid;
+ auto _psm = _o->psm;
+ auto _localMtu = _o->localMtu;
+ auto _remoteMtu = _o->remoteMtu;
+ auto _localMps = _o->localMps;
+ auto _remoteMps = _o->remoteMps;
+ auto _initialRxCredits = _o->initialRxCredits;
+ auto _initialTxCredits = _o->initialTxCredits;
+ return chre::fbs::CreateLeCocChannelInfo(
+ _fbb,
+ _localCid,
+ _remoteCid,
+ _psm,
+ _localMtu,
+ _remoteMtu,
+ _localMps,
+ _remoteMps,
+ _initialRxCredits,
+ _initialTxCredits);
+}
+
+inline BtSocketOpenT *BtSocketOpen::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::BtSocketOpenT> _o = std::unique_ptr<chre::fbs::BtSocketOpenT>(new BtSocketOpenT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void BtSocketOpen::UnPackTo(BtSocketOpenT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = socketId(); _o->socketId = _e; }
+ { auto _e = name(); if (_e) { _o->name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name[_i] = _e->Get(_i); } } }
+ { auto _e = aclConnectionHandle(); _o->aclConnectionHandle = _e; }
+ { auto _e = channelInfo_type(); _o->channelInfo.type = _e; }
+ { auto _e = channelInfo(); if (_e) _o->channelInfo.value = chre::fbs::ChannelInfoUnion::UnPack(_e, channelInfo_type(), _resolver); }
+ { auto _e = hubId(); _o->hubId = _e; }
+ { auto _e = endpointId(); _o->endpointId = _e; }
+}
+
+inline flatbuffers::Offset<BtSocketOpen> BtSocketOpen::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateBtSocketOpen(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpen(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BtSocketOpenT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _socketId = _o->socketId;
+ auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
+ auto _aclConnectionHandle = _o->aclConnectionHandle;
+ auto _channelInfo_type = _o->channelInfo.type;
+ auto _channelInfo = _o->channelInfo.Pack(_fbb);
+ auto _hubId = _o->hubId;
+ auto _endpointId = _o->endpointId;
+ return chre::fbs::CreateBtSocketOpen(
+ _fbb,
+ _socketId,
+ _name,
+ _aclConnectionHandle,
+ _channelInfo_type,
+ _channelInfo,
+ _hubId,
+ _endpointId);
+}
+
+inline BtSocketOpenResponseT *BtSocketOpenResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::BtSocketOpenResponseT> _o = std::unique_ptr<chre::fbs::BtSocketOpenResponseT>(new BtSocketOpenResponseT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void BtSocketOpenResponse::UnPackTo(BtSocketOpenResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = socketId(); _o->socketId = _e; }
+ { auto _e = status(); _o->status = _e; }
+ { auto _e = reason(); if (_e) { _o->reason.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->reason[_i] = _e->Get(_i); } } }
+}
+
+inline flatbuffers::Offset<BtSocketOpenResponse> BtSocketOpenResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateBtSocketOpenResponse(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponse(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketOpenResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BtSocketOpenResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _socketId = _o->socketId;
+ auto _status = _o->status;
+ auto _reason = _o->reason.size() ? _fbb.CreateVector(_o->reason) : 0;
+ return chre::fbs::CreateBtSocketOpenResponse(
+ _fbb,
+ _socketId,
+ _status,
+ _reason);
+}
+
+inline BtSocketCloseT *BtSocketClose::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::BtSocketCloseT> _o = std::unique_ptr<chre::fbs::BtSocketCloseT>(new BtSocketCloseT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void BtSocketClose::UnPackTo(BtSocketCloseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = socketId(); _o->socketId = _e; }
+ { auto _e = reason(); if (_e) { _o->reason.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->reason[_i] = _e->Get(_i); } } }
+}
+
+inline flatbuffers::Offset<BtSocketClose> BtSocketClose::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateBtSocketClose(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<BtSocketClose> CreateBtSocketClose(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BtSocketCloseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _socketId = _o->socketId;
+ auto _reason = _o->reason.size() ? _fbb.CreateVector(_o->reason) : 0;
+ return chre::fbs::CreateBtSocketClose(
+ _fbb,
+ _socketId,
+ _reason);
+}
+
+inline BtSocketCloseResponseT *BtSocketCloseResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::BtSocketCloseResponseT> _o = std::unique_ptr<chre::fbs::BtSocketCloseResponseT>(new BtSocketCloseResponseT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void BtSocketCloseResponse::UnPackTo(BtSocketCloseResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = socketId(); _o->socketId = _e; }
+}
+
+inline flatbuffers::Offset<BtSocketCloseResponse> BtSocketCloseResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateBtSocketCloseResponse(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<BtSocketCloseResponse> CreateBtSocketCloseResponse(flatbuffers::FlatBufferBuilder &_fbb, const BtSocketCloseResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BtSocketCloseResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _socketId = _o->socketId;
+ return chre::fbs::CreateBtSocketCloseResponse(
+ _fbb,
+ _socketId);
+}
+
+inline VendorHubInfoT *VendorHubInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::VendorHubInfoT> _o = std::unique_ptr<chre::fbs::VendorHubInfoT>(new VendorHubInfoT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void VendorHubInfo::UnPackTo(VendorHubInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) { _o->name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name[_i] = _e->Get(_i); } } }
+ { auto _e = version(); _o->version = _e; }
+ { auto _e = extended_info(); if (_e) { _o->extended_info.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->extended_info[_i] = _e->Get(_i); } } }
+}
+
+inline flatbuffers::Offset<VendorHubInfo> VendorHubInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VendorHubInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateVendorHubInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfo(flatbuffers::FlatBufferBuilder &_fbb, const VendorHubInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VendorHubInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
+ auto _version = _o->version;
+ auto _extended_info = _o->extended_info.size() ? _fbb.CreateVector(_o->extended_info) : 0;
+ return chre::fbs::CreateVendorHubInfo(
+ _fbb,
+ _name,
+ _version,
+ _extended_info);
+}
+
+inline MessageHubT *MessageHub::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::MessageHubT> _o = std::unique_ptr<chre::fbs::MessageHubT>(new MessageHubT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void MessageHub::UnPackTo(MessageHubT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); _o->id = _e; }
+ { auto _e = details_type(); _o->details.type = _e; }
+ { auto _e = details(); if (_e) _o->details.value = chre::fbs::MessageHubDetailsUnion::UnPack(_e, details_type(), _resolver); }
+}
+
+inline flatbuffers::Offset<MessageHub> MessageHub::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateMessageHub(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<MessageHub> CreateMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const MessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MessageHubT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id;
+ auto _details_type = _o->details.type;
+ auto _details = _o->details.Pack(_fbb);
+ return chre::fbs::CreateMessageHub(
+ _fbb,
+ _id,
+ _details_type,
+ _details);
+}
+
+inline RegisterMessageHubT *RegisterMessageHub::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::RegisterMessageHubT> _o = std::unique_ptr<chre::fbs::RegisterMessageHubT>(new RegisterMessageHubT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void RegisterMessageHub::UnPackTo(RegisterMessageHubT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = hub(); if (_e) _o->hub = std::unique_ptr<chre::fbs::MessageHubT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<RegisterMessageHub> RegisterMessageHub::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegisterMessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateRegisterMessageHub(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<RegisterMessageHub> CreateRegisterMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const RegisterMessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RegisterMessageHubT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _hub = _o->hub ? CreateMessageHub(_fbb, _o->hub.get(), _rehasher) : 0;
+ return chre::fbs::CreateRegisterMessageHub(
+ _fbb,
+ _hub);
+}
+
+inline UnregisterMessageHubT *UnregisterMessageHub::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::UnregisterMessageHubT> _o = std::unique_ptr<chre::fbs::UnregisterMessageHubT>(new UnregisterMessageHubT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void UnregisterMessageHub::UnPackTo(UnregisterMessageHubT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); _o->id = _e; }
+}
+
+inline flatbuffers::Offset<UnregisterMessageHub> UnregisterMessageHub::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterMessageHubT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateUnregisterMessageHub(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<UnregisterMessageHub> CreateUnregisterMessageHub(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterMessageHubT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnregisterMessageHubT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id;
+ return chre::fbs::CreateUnregisterMessageHub(
+ _fbb,
+ _id);
+}
+
+inline EndpointIdT *EndpointId::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointIdT> _o = std::unique_ptr<chre::fbs::EndpointIdT>(new EndpointIdT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointId::UnPackTo(EndpointIdT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = hubId(); _o->hubId = _e; }
+ { auto _e = id(); _o->id = _e; }
+}
+
+inline flatbuffers::Offset<EndpointId> EndpointId::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointIdT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointId(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointId> CreateEndpointId(flatbuffers::FlatBufferBuilder &_fbb, const EndpointIdT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointIdT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _hubId = _o->hubId;
+ auto _id = _o->id;
+ return chre::fbs::CreateEndpointId(
+ _fbb,
+ _hubId,
+ _id);
+}
+
+inline ServiceT *Service::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::ServiceT> _o = std::unique_ptr<chre::fbs::ServiceT>(new ServiceT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void Service::UnPackTo(ServiceT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = format(); _o->format = _e; }
+ { auto _e = descriptor(); if (_e) { _o->descriptor.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->descriptor[_i] = _e->Get(_i); } } }
+ { auto _e = major_version(); _o->major_version = _e; }
+ { auto _e = minor_version(); _o->minor_version = _e; }
+}
+
+inline flatbuffers::Offset<Service> Service::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateService(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Service> CreateService(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ServiceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _format = _o->format;
+ auto _descriptor = _o->descriptor.size() ? _fbb.CreateVector(_o->descriptor) : 0;
+ auto _major_version = _o->major_version;
+ auto _minor_version = _o->minor_version;
+ return chre::fbs::CreateService(
+ _fbb,
+ _format,
+ _descriptor,
+ _major_version,
+ _minor_version);
+}
+
+inline EndpointInfoT *EndpointInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointInfoT> _o = std::unique_ptr<chre::fbs::EndpointInfoT>(new EndpointInfoT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointInfo::UnPackTo(EndpointInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); if (_e) _o->id = std::unique_ptr<chre::fbs::EndpointIdT>(_e->UnPack(_resolver)); }
+ { auto _e = type(); _o->type = _e; }
+ { auto _e = name(); if (_e) { _o->name.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name[_i] = _e->Get(_i); } } }
+ { auto _e = version(); _o->version = _e; }
+ { auto _e = required_permissions(); _o->required_permissions = _e; }
+ { auto _e = services(); if (_e) { _o->services.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->services[_i] = std::unique_ptr<chre::fbs::ServiceT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<EndpointInfo> EndpointInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfo(flatbuffers::FlatBufferBuilder &_fbb, const EndpointInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id ? CreateEndpointId(_fbb, _o->id.get(), _rehasher) : 0;
+ auto _type = _o->type;
+ auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
+ auto _version = _o->version;
+ auto _required_permissions = _o->required_permissions;
+ auto _services = _o->services.size() ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::Service>> (_o->services.size(), [](size_t i, _VectorArgs *__va) { return CreateService(*__va->__fbb, __va->__o->services[i].get(), __va->__rehasher); }, &_va ) : 0;
+ return chre::fbs::CreateEndpointInfo(
+ _fbb,
+ _id,
+ _type,
+ _name,
+ _version,
+ _required_permissions,
+ _services);
+}
+
+inline RegisterEndpointT *RegisterEndpoint::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::RegisterEndpointT> _o = std::unique_ptr<chre::fbs::RegisterEndpointT>(new RegisterEndpointT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void RegisterEndpoint::UnPackTo(RegisterEndpointT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = endpoint(); if (_e) _o->endpoint = std::unique_ptr<chre::fbs::EndpointInfoT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<RegisterEndpoint> RegisterEndpoint::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegisterEndpointT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateRegisterEndpoint(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<RegisterEndpoint> CreateRegisterEndpoint(flatbuffers::FlatBufferBuilder &_fbb, const RegisterEndpointT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RegisterEndpointT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _endpoint = _o->endpoint ? CreateEndpointInfo(_fbb, _o->endpoint.get(), _rehasher) : 0;
+ return chre::fbs::CreateRegisterEndpoint(
+ _fbb,
+ _endpoint);
+}
+
+inline UnregisterEndpointT *UnregisterEndpoint::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::UnregisterEndpointT> _o = std::unique_ptr<chre::fbs::UnregisterEndpointT>(new UnregisterEndpointT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void UnregisterEndpoint::UnPackTo(UnregisterEndpointT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = endpoint(); if (_e) _o->endpoint = std::unique_ptr<chre::fbs::EndpointIdT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<UnregisterEndpoint> UnregisterEndpoint::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterEndpointT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateUnregisterEndpoint(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<UnregisterEndpoint> CreateUnregisterEndpoint(flatbuffers::FlatBufferBuilder &_fbb, const UnregisterEndpointT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnregisterEndpointT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _endpoint = _o->endpoint ? CreateEndpointId(_fbb, _o->endpoint.get(), _rehasher) : 0;
+ return chre::fbs::CreateUnregisterEndpoint(
+ _fbb,
+ _endpoint);
+}
+
+inline GetMessageHubsAndEndpointsRequestT *GetMessageHubsAndEndpointsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::GetMessageHubsAndEndpointsRequestT> _o = std::unique_ptr<chre::fbs::GetMessageHubsAndEndpointsRequestT>(new GetMessageHubsAndEndpointsRequestT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void GetMessageHubsAndEndpointsRequest::UnPackTo(GetMessageHubsAndEndpointsRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> GetMessageHubsAndEndpointsRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateGetMessageHubsAndEndpointsRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> CreateGetMessageHubsAndEndpointsRequest(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GetMessageHubsAndEndpointsRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ return chre::fbs::CreateGetMessageHubsAndEndpointsRequest(
+ _fbb);
+}
+
+inline GetMessageHubsAndEndpointsResponseT *GetMessageHubsAndEndpointsResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::GetMessageHubsAndEndpointsResponseT> _o = std::unique_ptr<chre::fbs::GetMessageHubsAndEndpointsResponseT>(new GetMessageHubsAndEndpointsResponseT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void GetMessageHubsAndEndpointsResponse::UnPackTo(GetMessageHubsAndEndpointsResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = hubs(); if (_e) { _o->hubs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->hubs[_i] = std::unique_ptr<chre::fbs::MessageHubT>(_e->Get(_i)->UnPack(_resolver)); } } }
+ { auto _e = endpoints(); if (_e) { _o->endpoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->endpoints[_i] = std::unique_ptr<chre::fbs::EndpointInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> GetMessageHubsAndEndpointsResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateGetMessageHubsAndEndpointsResponse(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponse(flatbuffers::FlatBufferBuilder &_fbb, const GetMessageHubsAndEndpointsResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GetMessageHubsAndEndpointsResponseT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _hubs = _o->hubs.size() ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MessageHub>> (_o->hubs.size(), [](size_t i, _VectorArgs *__va) { return CreateMessageHub(*__va->__fbb, __va->__o->hubs[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _endpoints = _o->endpoints.size() ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::EndpointInfo>> (_o->endpoints.size(), [](size_t i, _VectorArgs *__va) { return CreateEndpointInfo(*__va->__fbb, __va->__o->endpoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+ return chre::fbs::CreateGetMessageHubsAndEndpointsResponse(
+ _fbb,
+ _hubs,
+ _endpoints);
+}
+
+inline OpenEndpointSessionRequestT *OpenEndpointSessionRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::OpenEndpointSessionRequestT> _o = std::unique_ptr<chre::fbs::OpenEndpointSessionRequestT>(new OpenEndpointSessionRequestT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void OpenEndpointSessionRequest::UnPackTo(OpenEndpointSessionRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); _o->id = _e; }
+ { auto _e = fromEndpoint(); if (_e) _o->fromEndpoint = std::unique_ptr<chre::fbs::EndpointIdT>(_e->UnPack(_resolver)); }
+ { auto _e = toEndpoint(); if (_e) _o->toEndpoint = std::unique_ptr<chre::fbs::EndpointIdT>(_e->UnPack(_resolver)); }
+ { auto _e = serviceDescriptor(); if (_e) { _o->serviceDescriptor.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->serviceDescriptor[_i] = _e->Get(_i); } } }
+}
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> OpenEndpointSessionRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OpenEndpointSessionRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateOpenEndpointSessionRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequest(flatbuffers::FlatBufferBuilder &_fbb, const OpenEndpointSessionRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OpenEndpointSessionRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id;
+ auto _fromEndpoint = _o->fromEndpoint ? CreateEndpointId(_fbb, _o->fromEndpoint.get(), _rehasher) : 0;
+ auto _toEndpoint = _o->toEndpoint ? CreateEndpointId(_fbb, _o->toEndpoint.get(), _rehasher) : 0;
+ auto _serviceDescriptor = _o->serviceDescriptor.size() ? _fbb.CreateVector(_o->serviceDescriptor) : 0;
+ return chre::fbs::CreateOpenEndpointSessionRequest(
+ _fbb,
+ _id,
+ _fromEndpoint,
+ _toEndpoint,
+ _serviceDescriptor);
+}
+
+inline EndpointSessionOpenedT *EndpointSessionOpened::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointSessionOpenedT> _o = std::unique_ptr<chre::fbs::EndpointSessionOpenedT>(new EndpointSessionOpenedT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointSessionOpened::UnPackTo(EndpointSessionOpenedT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); _o->id = _e; }
+}
+
+inline flatbuffers::Offset<EndpointSessionOpened> EndpointSessionOpened::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionOpenedT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointSessionOpened(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointSessionOpened> CreateEndpointSessionOpened(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionOpenedT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointSessionOpenedT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id;
+ return chre::fbs::CreateEndpointSessionOpened(
+ _fbb,
+ _id);
+}
+
+inline EndpointSessionClosedT *EndpointSessionClosed::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointSessionClosedT> _o = std::unique_ptr<chre::fbs::EndpointSessionClosedT>(new EndpointSessionClosedT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointSessionClosed::UnPackTo(EndpointSessionClosedT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = id(); _o->id = _e; }
+ { auto _e = reason(); _o->reason = _e; }
+}
+
+inline flatbuffers::Offset<EndpointSessionClosed> EndpointSessionClosed::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionClosedT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointSessionClosed(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointSessionClosed> CreateEndpointSessionClosed(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionClosedT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointSessionClosedT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _id = _o->id;
+ auto _reason = _o->reason;
+ return chre::fbs::CreateEndpointSessionClosed(
+ _fbb,
+ _id,
+ _reason);
+}
+
+inline EndpointSessionMessageT *EndpointSessionMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointSessionMessageT> _o = std::unique_ptr<chre::fbs::EndpointSessionMessageT>(new EndpointSessionMessageT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointSessionMessage::UnPackTo(EndpointSessionMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = session_id(); _o->session_id = _e; }
+ { auto _e = type(); _o->type = _e; }
+ { auto _e = permissions(); _o->permissions = _e; }
+ { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } }
+ { auto _e = flags(); _o->flags = _e; }
+ { auto _e = sequence_number(); _o->sequence_number = _e; }
+}
+
+inline flatbuffers::Offset<EndpointSessionMessage> EndpointSessionMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointSessionMessage(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessage(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointSessionMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _session_id = _o->session_id;
+ auto _type = _o->type;
+ auto _permissions = _o->permissions;
+ auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0;
+ auto _flags = _o->flags;
+ auto _sequence_number = _o->sequence_number;
+ return chre::fbs::CreateEndpointSessionMessage(
+ _fbb,
+ _session_id,
+ _type,
+ _permissions,
+ _data,
+ _flags,
+ _sequence_number);
+}
+
+inline EndpointSessionMessageDeliveryStatusT *EndpointSessionMessageDeliveryStatus::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ std::unique_ptr<chre::fbs::EndpointSessionMessageDeliveryStatusT> _o = std::unique_ptr<chre::fbs::EndpointSessionMessageDeliveryStatusT>(new EndpointSessionMessageDeliveryStatusT());
+ UnPackTo(_o.get(), _resolver);
+ return _o.release();
+}
+
+inline void EndpointSessionMessageDeliveryStatus::UnPackTo(EndpointSessionMessageDeliveryStatusT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = session_id(); _o->session_id = _e; }
+ { auto _e = status(); if (_e) _o->status = std::unique_ptr<chre::fbs::MessageDeliveryStatusT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> EndpointSessionMessageDeliveryStatus::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageDeliveryStatusT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEndpointSessionMessageDeliveryStatus(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> CreateEndpointSessionMessageDeliveryStatus(flatbuffers::FlatBufferBuilder &_fbb, const EndpointSessionMessageDeliveryStatusT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EndpointSessionMessageDeliveryStatusT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _session_id = _o->session_id;
+ auto _status = _o->status ? CreateMessageDeliveryStatus(_fbb, _o->status.get(), _rehasher) : 0;
+ return chre::fbs::CreateEndpointSessionMessageDeliveryStatus(
+ _fbb,
+ _session_id,
+ _status);
+}
+
inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
std::unique_ptr<chre::fbs::MessageContainerT> _o = std::unique_ptr<chre::fbs::MessageContainerT>(new MessageContainerT());
UnPackTo(_o.get(), _resolver);
@@ -5249,6 +8706,165 @@
_host_addr);
}
+inline bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type) {
+ switch (type) {
+ case ChannelInfo::NONE: {
+ return true;
+ }
+ case ChannelInfo::LeCocChannelInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::LeCocChannelInfo *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+ if (!values || !types) return !values && !types;
+ if (values->size() != types->size()) return false;
+ for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+ if (!VerifyChannelInfo(
+ verifier, values->Get(i), types->GetEnum<ChannelInfo>(i))) {
+ return false;
+ }
+ }
+ return true;
+}
+
+inline void *ChannelInfoUnion::UnPack(const void *obj, ChannelInfo type, const flatbuffers::resolver_function_t *resolver) {
+ switch (type) {
+ case ChannelInfo::LeCocChannelInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::LeCocChannelInfo *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ default: return nullptr;
+ }
+}
+
+inline flatbuffers::Offset<void> ChannelInfoUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+ switch (type) {
+ case ChannelInfo::LeCocChannelInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::LeCocChannelInfoT *>(value);
+ return CreateLeCocChannelInfo(_fbb, ptr, _rehasher).Union();
+ }
+ default: return 0;
+ }
+}
+
+inline ChannelInfoUnion::ChannelInfoUnion(const ChannelInfoUnion &u) : type(u.type), value(nullptr) {
+ switch (type) {
+ case ChannelInfo::LeCocChannelInfo: {
+ value = new chre::fbs::LeCocChannelInfoT(*reinterpret_cast<chre::fbs::LeCocChannelInfoT *>(u.value));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+inline void ChannelInfoUnion::Reset() {
+ switch (type) {
+ case ChannelInfo::LeCocChannelInfo: {
+ auto ptr = reinterpret_cast<chre::fbs::LeCocChannelInfoT *>(value);
+ delete ptr;
+ break;
+ }
+ default: break;
+ }
+ value = nullptr;
+ type = ChannelInfo::NONE;
+}
+
+inline bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type) {
+ switch (type) {
+ case MessageHubDetails::NONE: {
+ return true;
+ }
+ case MessageHubDetails::HubInfoResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::VendorHubInfo *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+ if (!values || !types) return !values && !types;
+ if (values->size() != types->size()) return false;
+ for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+ if (!VerifyMessageHubDetails(
+ verifier, values->Get(i), types->GetEnum<MessageHubDetails>(i))) {
+ return false;
+ }
+ }
+ return true;
+}
+
+inline void *MessageHubDetailsUnion::UnPack(const void *obj, MessageHubDetails type, const flatbuffers::resolver_function_t *resolver) {
+ switch (type) {
+ case MessageHubDetails::HubInfoResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::VendorHubInfo *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ default: return nullptr;
+ }
+}
+
+inline flatbuffers::Offset<void> MessageHubDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+ switch (type) {
+ case MessageHubDetails::HubInfoResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponseT *>(value);
+ return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union();
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::VendorHubInfoT *>(value);
+ return CreateVendorHubInfo(_fbb, ptr, _rehasher).Union();
+ }
+ default: return 0;
+ }
+}
+
+inline MessageHubDetailsUnion::MessageHubDetailsUnion(const MessageHubDetailsUnion &u) : type(u.type), value(nullptr) {
+ switch (type) {
+ case MessageHubDetails::HubInfoResponse: {
+ value = new chre::fbs::HubInfoResponseT(*reinterpret_cast<chre::fbs::HubInfoResponseT *>(u.value));
+ break;
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ value = new chre::fbs::VendorHubInfoT(*reinterpret_cast<chre::fbs::VendorHubInfoT *>(u.value));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+inline void MessageHubDetailsUnion::Reset() {
+ switch (type) {
+ case MessageHubDetails::HubInfoResponse: {
+ auto ptr = reinterpret_cast<chre::fbs::HubInfoResponseT *>(value);
+ delete ptr;
+ break;
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ auto ptr = reinterpret_cast<chre::fbs::VendorHubInfoT *>(value);
+ delete ptr;
+ break;
+ }
+ default: break;
+ }
+ value = nullptr;
+ type = MessageHubDetails::NONE;
+}
+
inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
switch (type) {
case ChreMessage::NONE: {
@@ -5382,6 +8998,66 @@
auto ptr = reinterpret_cast<const chre::fbs::MessageDeliveryStatus *>(obj);
return verifier.VerifyTable(ptr);
}
+ case ChreMessage::BtSocketOpen: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpen *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketClose: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketClose *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::RegisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterMessageHub *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterMessageHub *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::RegisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterEndpoint *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterEndpoint *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::OpenEndpointSessionRequest *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionOpened *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionClosed *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessage *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
default: return true;
}
}
@@ -5528,6 +9204,66 @@
auto ptr = reinterpret_cast<const chre::fbs::MessageDeliveryStatus *>(obj);
return ptr->UnPack(resolver);
}
+ case ChreMessage::BtSocketOpen: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpen *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenResponse *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::BtSocketClose: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketClose *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseResponse *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::RegisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterMessageHub *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterMessageHub *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::RegisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterEndpoint *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterEndpoint *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::OpenEndpointSessionRequest *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionOpened *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionClosed *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessage *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(obj);
+ return ptr->UnPack(resolver);
+ }
default: return nullptr;
}
}
@@ -5662,6 +9398,66 @@
auto ptr = reinterpret_cast<const chre::fbs::MessageDeliveryStatusT *>(value);
return CreateMessageDeliveryStatus(_fbb, ptr, _rehasher).Union();
}
+ case ChreMessage::BtSocketOpen: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenT *>(value);
+ return CreateBtSocketOpen(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenResponseT *>(value);
+ return CreateBtSocketOpenResponse(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::BtSocketClose: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseT *>(value);
+ return CreateBtSocketClose(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseResponseT *>(value);
+ return CreateBtSocketCloseResponse(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequestT *>(value);
+ return CreateGetMessageHubsAndEndpointsRequest(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponseT *>(value);
+ return CreateGetMessageHubsAndEndpointsResponse(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::RegisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterMessageHubT *>(value);
+ return CreateRegisterMessageHub(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterMessageHubT *>(value);
+ return CreateUnregisterMessageHub(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::RegisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterEndpointT *>(value);
+ return CreateRegisterEndpoint(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterEndpointT *>(value);
+ return CreateUnregisterEndpoint(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::OpenEndpointSessionRequestT *>(value);
+ return CreateOpenEndpointSessionRequest(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionOpenedT *>(value);
+ return CreateEndpointSessionOpened(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionClosedT *>(value);
+ return CreateEndpointSessionClosed(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageT *>(value);
+ return CreateEndpointSessionMessage(_fbb, ptr, _rehasher).Union();
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatusT *>(value);
+ return CreateEndpointSessionMessageDeliveryStatus(_fbb, ptr, _rehasher).Union();
+ }
default: return 0;
}
}
@@ -5796,6 +9592,66 @@
value = new chre::fbs::MessageDeliveryStatusT(*reinterpret_cast<chre::fbs::MessageDeliveryStatusT *>(u.value));
break;
}
+ case ChreMessage::BtSocketOpen: {
+ value = new chre::fbs::BtSocketOpenT(*reinterpret_cast<chre::fbs::BtSocketOpenT *>(u.value));
+ break;
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ value = new chre::fbs::BtSocketOpenResponseT(*reinterpret_cast<chre::fbs::BtSocketOpenResponseT *>(u.value));
+ break;
+ }
+ case ChreMessage::BtSocketClose: {
+ value = new chre::fbs::BtSocketCloseT(*reinterpret_cast<chre::fbs::BtSocketCloseT *>(u.value));
+ break;
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ value = new chre::fbs::BtSocketCloseResponseT(*reinterpret_cast<chre::fbs::BtSocketCloseResponseT *>(u.value));
+ break;
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ value = new chre::fbs::GetMessageHubsAndEndpointsRequestT(*reinterpret_cast<chre::fbs::GetMessageHubsAndEndpointsRequestT *>(u.value));
+ break;
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::GetMessageHubsAndEndpointsResponseT not copyable.
+ break;
+ }
+ case ChreMessage::RegisterMessageHub: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::RegisterMessageHubT not copyable.
+ break;
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ value = new chre::fbs::UnregisterMessageHubT(*reinterpret_cast<chre::fbs::UnregisterMessageHubT *>(u.value));
+ break;
+ }
+ case ChreMessage::RegisterEndpoint: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::RegisterEndpointT not copyable.
+ break;
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::UnregisterEndpointT not copyable.
+ break;
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::OpenEndpointSessionRequestT not copyable.
+ break;
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ value = new chre::fbs::EndpointSessionOpenedT(*reinterpret_cast<chre::fbs::EndpointSessionOpenedT *>(u.value));
+ break;
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ value = new chre::fbs::EndpointSessionClosedT(*reinterpret_cast<chre::fbs::EndpointSessionClosedT *>(u.value));
+ break;
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ value = new chre::fbs::EndpointSessionMessageT(*reinterpret_cast<chre::fbs::EndpointSessionMessageT *>(u.value));
+ break;
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ FLATBUFFERS_ASSERT(false); // chre::fbs::EndpointSessionMessageDeliveryStatusT not copyable.
+ break;
+ }
default:
break;
}
@@ -5963,6 +9819,81 @@
delete ptr;
break;
}
+ case ChreMessage::BtSocketOpen: {
+ auto ptr = reinterpret_cast<chre::fbs::BtSocketOpenT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ auto ptr = reinterpret_cast<chre::fbs::BtSocketOpenResponseT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::BtSocketClose: {
+ auto ptr = reinterpret_cast<chre::fbs::BtSocketCloseT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ auto ptr = reinterpret_cast<chre::fbs::BtSocketCloseResponseT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ auto ptr = reinterpret_cast<chre::fbs::GetMessageHubsAndEndpointsRequestT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ auto ptr = reinterpret_cast<chre::fbs::GetMessageHubsAndEndpointsResponseT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::RegisterMessageHub: {
+ auto ptr = reinterpret_cast<chre::fbs::RegisterMessageHubT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ auto ptr = reinterpret_cast<chre::fbs::UnregisterMessageHubT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::RegisterEndpoint: {
+ auto ptr = reinterpret_cast<chre::fbs::RegisterEndpointT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ auto ptr = reinterpret_cast<chre::fbs::UnregisterEndpointT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ auto ptr = reinterpret_cast<chre::fbs::OpenEndpointSessionRequestT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ auto ptr = reinterpret_cast<chre::fbs::EndpointSessionOpenedT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ auto ptr = reinterpret_cast<chre::fbs::EndpointSessionClosedT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ auto ptr = reinterpret_cast<chre::fbs::EndpointSessionMessageT *>(value);
+ delete ptr;
+ break;
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ auto ptr = reinterpret_cast<chre::fbs::EndpointSessionMessageDeliveryStatusT *>(value);
+ delete ptr;
+ break;
+ }
default: break;
}
value = nullptr;
diff --git a/host/common/include/chre_host/hal_error.h b/host/common/include/chre_host/hal_error.h
index 987ab40..9b3100d 100644
--- a/host/common/include/chre_host/hal_error.h
+++ b/host/common/include/chre_host/hal_error.h
@@ -28,6 +28,7 @@
OPERATION_FAILED = -1,
INVALID_RESULT = -2,
INVALID_ARGUMENT = -3,
+ CHRE_NOT_READY = -4,
// Hal client errors
BINDER_CONNECTION_FAILED = -100,
diff --git a/host/common/include/chre_host/host_protocol_host.h b/host/common/include/chre_host/host_protocol_host.h
index 35f1ced..80c0b04 100644
--- a/host/common/include/chre_host/host_protocol_host.h
+++ b/host/common/include/chre_host/host_protocol_host.h
@@ -74,6 +74,11 @@
virtual void handleSelfTestResponse(
const ::chre::fbs::SelfTestResponseT & /*response*/){};
+
+ virtual bool handleContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion & /*msg*/) {
+ return false;
+ };
};
/**
diff --git a/host/common/include/chre_host/preloaded_nanoapp_loader.h b/host/common/include/chre_host/preloaded_nanoapp_loader.h
index e2c83bf..c830178 100644
--- a/host/common/include/chre_host/preloaded_nanoapp_loader.h
+++ b/host/common/include/chre_host/preloaded_nanoapp_loader.h
@@ -101,6 +101,13 @@
size_t fragmentId;
};
+ /** The possible results of verification of a fragment load response. */
+ enum class ResponseVerificationResult {
+ SUCCESS = 0,
+ FAILURE = 1,
+ IGNORED = 2,
+ };
+
/**
* Loads a preloaded nanoapp.
*
@@ -130,10 +137,11 @@
const FragmentedLoadRequest &request);
/** Verifies the response of a loading request. */
- [[nodiscard]] bool verifyFragmentLoadResponse(
+ [[nodiscard]] ResponseVerificationResult verifyFragmentLoadResponse(
const ::chre::fbs::LoadNanoappResponseT &response) const;
- Transaction mPreloadedNanoappPendingTransaction{0, 0};
+ Transaction mPendingTransaction{/* transactionId= */ 0,
+ /* fragmentId= */ 0};
/** The value of this promise carries the result in the load response. */
std::optional<std::promise<bool>> mFragmentedLoadPromise = std::nullopt;
diff --git a/host/common/include/chre_host/wifi_ext_hal_handler.h b/host/common/include/chre_host/wifi_ext_hal_handler.h
index d83a625..ee0f6e9 100644
--- a/host/common/include/chre_host/wifi_ext_hal_handler.h
+++ b/host/common/include/chre_host/wifi_ext_hal_handler.h
@@ -28,7 +28,6 @@
#include <string>
#include <thread>
-#include <aidl/android/hardware/wifi/WifiStatusCode.h>
#include <aidl/vendor/google/wifi_ext/BnWifiExtChreCallback.h>
#include <aidl/vendor/google/wifi_ext/IWifiExt.h>
#include <android/binder_manager.h>
@@ -44,7 +43,6 @@
*/
class WifiExtHalHandler {
public:
- using WifiStatusCode = aidl::android::hardware::wifi::WifiStatusCode;
using IWifiExt = aidl::vendor::google::wifi_ext::IWifiExt;
using BnWifiExtChreNanCallback =
aidl::vendor::google::wifi_ext::BnWifiExtChreCallback;
diff --git a/host/common/log_message_parser.cc b/host/common/log_message_parser.cc
index 2499123..8477157 100644
--- a/host/common/log_message_parser.cc
+++ b/host/common/log_message_parser.cc
@@ -268,7 +268,7 @@
size_t bufferIndex = 0;
const LogMessageV2 *message = nullptr;
size_t maxLogMessageLen = 0;
- while (bufferIndex + kLogHeaderSize <= logBufferSize) {
+ while (bufferIndex + kLogHeaderSize < logBufferSize) {
message = reinterpret_cast<const LogMessageV2 *>(&logBuffer[bufferIndex]);
maxLogMessageLen = (logBufferSize - bufferIndex) - kLogHeaderSize;
logMessageSize = std::nullopt;
diff --git a/host/common/preloaded_nanoapp_loader.cc b/host/common/preloaded_nanoapp_loader.cc
index 7d198a5..5e5d89f 100644
--- a/host/common/preloaded_nanoapp_loader.cc
+++ b/host/common/preloaded_nanoapp_loader.cc
@@ -197,21 +197,35 @@
return success;
}
-bool PreloadedNanoappLoader::verifyFragmentLoadResponse(
+PreloadedNanoappLoader::ResponseVerificationResult
+PreloadedNanoappLoader::verifyFragmentLoadResponse(
const ::chre::fbs::LoadNanoappResponseT &response) const {
- if (!response.success) {
- LOGE("Loading nanoapp binary fragment %d of transaction %u failed.",
- response.fragment_id, response.transaction_id);
- return false;
+ // Allow seen fragment ids to be ignored to tolerate duplicated responses.
+ if (response.fragment_id >= 0 &&
+ response.fragment_id < mPendingTransaction.fragmentId) {
+ LOGW(
+ "Fragmented load response has a fragment id %u while %zu is expected. "
+ "Ignored",
+ response.fragment_id, mPendingTransaction.fragmentId);
+ return ResponseVerificationResult::IGNORED;
}
- if (mPreloadedNanoappPendingTransaction.fragmentId != response.fragment_id) {
+
+ // Future or negative fragment ids are not acceptable.
+ if (response.fragment_id != mPendingTransaction.fragmentId) {
LOGE(
"Fragmented load response with unexpected fragment id %u while "
"%zu is expected",
- response.fragment_id, mPreloadedNanoappPendingTransaction.fragmentId);
- return false;
+ response.fragment_id, mPendingTransaction.fragmentId);
+ return ResponseVerificationResult::FAILURE;
}
- return true;
+
+ // Once fragment id is matched the result is taken.
+ if (!response.success) {
+ LOGE("Loading nanoapp binary fragment %d of transaction %u failed.",
+ response.fragment_id, response.transaction_id);
+ return ResponseVerificationResult::FAILURE;
+ }
+ return ResponseVerificationResult::SUCCESS;
}
bool PreloadedNanoappLoader::onLoadNanoappResponse(
@@ -225,19 +239,23 @@
response.transaction_id, response.fragment_id);
return false;
}
- if (mPreloadedNanoappPendingTransaction.transactionId !=
- response.transaction_id) {
+ if (mPendingTransaction.transactionId != response.transaction_id) {
LOGE(
"Fragmented load response with transactionId %u but transactionId "
"%u is expected. Ignored.",
- response.transaction_id,
- mPreloadedNanoappPendingTransaction.transactionId);
+ response.transaction_id, mPendingTransaction.transactionId);
return false;
}
+
// set value for the future instance.
- mFragmentedLoadPromise->set_value(verifyFragmentLoadResponse(response));
- // reset the promise as the value can only be retrieved once from it.
- mFragmentedLoadPromise = std::nullopt;
+ ResponseVerificationResult result = verifyFragmentLoadResponse(response);
+ if (result != ResponseVerificationResult::IGNORED) {
+ mFragmentedLoadPromise->set_value(result ==
+ ResponseVerificationResult::SUCCESS);
+ // reset the promise as the value can only be retrieved once from it.
+ mFragmentedLoadPromise = std::nullopt;
+ }
+
return true;
}
@@ -257,7 +275,7 @@
// Returns an invalid future to indicate the failure
return std::future<bool>{};
}
- mPreloadedNanoappPendingTransaction = {
+ mPendingTransaction = {
.transactionId = request.transactionId,
.fragmentId = request.fragmentId,
};
diff --git a/host/hal_generic/Android.bp b/host/hal_generic/Android.bp
index f844ec2..b9edabd 100644
--- a/host/hal_generic/Android.bp
+++ b/host/hal_generic/Android.bp
@@ -31,10 +31,7 @@
defaults: ["chre_aidl_hal_generic_defaults"],
vendor: true,
relative_install_path: "hw",
- srcs: [
- ":hal_aidl_generic_srcs",
- "aidl/service.cc",
- ],
+ srcs: ["aidl/service.cc"],
init_rc: ["aidl/android.hardware.contexthub-service.generic.rc"],
vintf_fragments: ["aidl/android.hardware.contexthub-service.generic.xml"],
visibility: ["//visibility:public"],
@@ -51,42 +48,22 @@
cc_defaults {
name: "chre_aidl_hal_generic_defaults",
+ defaults: [
+ "//system/chre:contexthub_hal_defaults",
+ "//system/chre:pw_rpc_cflags_chre",
+ "//system/chre:pw_rpc_nanopb_lib_dependencies",
+ ],
vendor: true,
- include_dirs: [
- "system/chre/host/hal_generic/common/",
- "system/chre/util/include",
+ srcs: [
+ "//system/chre/host/hal_generic:hal_aidl_generic_srcs",
+ "//system/chre:contexthub_hal_client_srcs",
],
cflags: [
"-DCHRE_HAL_SOCKET_METRICS_ENABLED",
- "-DCHRE_IS_HOST_BUILD",
- "-DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4000", // Needed to import CHRE APIs.
- "-Wall",
- "-Werror",
- ],
- header_libs: [
- "chre_api",
- ],
- shared_libs: [
- "android.frameworks.stats-V2-ndk",
- "android.hardware.contexthub-V3-ndk",
- "chre_atoms_log",
- "chremetrics-cpp",
- "libbase",
- "libbinder_ndk",
- "libcutils",
- "libjsoncpp",
- "liblog",
- "libprotobuf-cpp-lite",
- "libutils",
- "server_configurable_flags",
- "libaconfig_storage_read_api_cc",
+ "-Wthread-safety", // Need to be explicitly set
],
static_libs: [
- "chre_client",
"chre_config_util",
- "chre_flags_c_lib",
- "chre_metrics_reporter",
- "event_logger",
],
}
diff --git a/host/hal_generic/aidl/android.hardware.contexthub-service.generic.xml b/host/hal_generic/aidl/android.hardware.contexthub-service.generic.xml
index 2f8ddc8..359bb0a 100644
--- a/host/hal_generic/aidl/android.hardware.contexthub-service.generic.xml
+++ b/host/hal_generic/aidl/android.hardware.contexthub-service.generic.xml
@@ -1,7 +1,7 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.contexthub</name>
- <version>3</version>
+ <version>4</version>
<interface>
<name>IContextHub</name>
<instance>default</instance>
diff --git a/host/hal_generic/aidl/generic_context_hub_aidl.cc b/host/hal_generic/aidl/generic_context_hub_aidl.cc
index de13bc0..e72e3ed 100644
--- a/host/hal_generic/aidl/generic_context_hub_aidl.cc
+++ b/host/hal_generic/aidl/generic_context_hub_aidl.cc
@@ -351,6 +351,73 @@
return ndk::ScopedAStatus::ok();
}
+ScopedAStatus ContextHub::getHubs(std::vector<HubInfo> *hubs) {
+ if (mV4Impl) return mV4Impl->getHubs(hubs);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::getEndpoints(std::vector<EndpointInfo> *endpoints) {
+ if (mV4Impl) return mV4Impl->getEndpoints(endpoints);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::registerEndpoint(const EndpointInfo &endpoint) {
+ if (mV4Impl) return mV4Impl->registerEndpoint(endpoint);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::unregisterEndpoint(const EndpointInfo &endpoint) {
+ if (mV4Impl) return mV4Impl->unregisterEndpoint(endpoint);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback) {
+ if (mV4Impl) return mV4Impl->registerEndpointCallback(callback);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::requestSessionIdRange(int32_t size,
+ std::vector<int32_t> *ids) {
+ if (mV4Impl) return mV4Impl->requestSessionIdRange(size, ids);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> &serviceDescriptor) {
+ if (mV4Impl) {
+ return mV4Impl->openEndpointSession(sessionId, destination, initiator,
+ serviceDescriptor);
+ }
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::sendMessageToEndpoint(int32_t sessionId,
+ const Message &msg) {
+ if (mV4Impl) return mV4Impl->sendMessageToEndpoint(sessionId, msg);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus &msgStatus) {
+ if (mV4Impl)
+ return mV4Impl->sendMessageDeliveryStatusToEndpoint(sessionId, msgStatus);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::closeEndpointSession(int32_t sessionId,
+ Reason reason) {
+ if (mV4Impl) return mV4Impl->closeEndpointSession(sessionId, reason);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHub::endpointSessionOpenComplete(int32_t sessionId) {
+ if (mV4Impl) return mV4Impl->endpointSessionOpenComplete(sessionId);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
void ContextHub::onNanoappMessage(const ::chre::fbs::NanoappMessageT &message) {
std::lock_guard<std::mutex> lock(mCallbackMutex);
if (mCallback != nullptr) {
@@ -461,6 +528,12 @@
debugDumpComplete();
}
+bool ContextHub::onContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion &message) {
+ if (mV4Impl) return mV4Impl->handleMessageFromChre(message);
+ return false;
+}
+
void ContextHub::handleServiceDeath() {
LOGI("Context Hub Service died ...");
{
diff --git a/host/hal_generic/aidl/generic_context_hub_aidl.h b/host/hal_generic/aidl/generic_context_hub_aidl.h
index 024cb1e..7dd85b0 100644
--- a/host/hal_generic/aidl/generic_context_hub_aidl.h
+++ b/host/hal_generic/aidl/generic_context_hub_aidl.h
@@ -18,8 +18,10 @@
#define ANDROID_HARDWARE_CONTEXTHUB_AIDL_CONTEXTHUB_H
#include <aidl/android/hardware/contexthub/BnContextHub.h>
+#include <android_chre_flags.h>
#include <log/log.h>
#include <atomic>
+#include <functional>
#include <future>
#include <map>
#include <mutex>
@@ -27,6 +29,7 @@
#include <unordered_set>
#include "chre_host/napp_header.h"
+#include "context_hub_v4_impl.h"
#include "debug_dump_helper.h"
#include "event_logger.h"
#include "hal_chre_socket_connection.h"
@@ -56,7 +59,13 @@
public:
ContextHub()
: mDeathRecipient(
- AIBinder_DeathRecipient_new(ContextHub::onServiceDied)) {}
+ AIBinder_DeathRecipient_new(ContextHub::onServiceDied)) {
+ if (::android::chre::flags::offload_implementation()) {
+ mV4Impl.emplace([this](uint8_t *data, size_t size) {
+ return mConnection.sendRawMessage(data, size);
+ });
+ }
+ }
::ndk::ScopedAStatus getContextHubs(
std::vector<ContextHubInfo> *out_contextHubInfos) override;
::ndk::ScopedAStatus loadNanoapp(int32_t contextHubId,
@@ -88,6 +97,27 @@
char16_t in_hostEndpointId) override;
::ndk::ScopedAStatus onNanSessionStateChanged(
const NanSessionStateUpdate &in_update) override;
+ ::ndk::ScopedAStatus getHubs(std::vector<HubInfo> *hubs) override;
+ ::ndk::ScopedAStatus getEndpoints(
+ std::vector<EndpointInfo> *endpoints) override;
+ ::ndk::ScopedAStatus registerEndpoint(const EndpointInfo &endpoint) override;
+ ::ndk::ScopedAStatus unregisterEndpoint(
+ const EndpointInfo &endpoint) override;
+ ::ndk::ScopedAStatus registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback) override;
+ ::ndk::ScopedAStatus requestSessionIdRange(
+ int32_t size, std::vector<int32_t> *ids) override;
+ ::ndk::ScopedAStatus openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> &serviceDescriptor) override;
+ ::ndk::ScopedAStatus sendMessageToEndpoint(int32_t sessionId,
+ const Message &msg) override;
+ ::ndk::ScopedAStatus sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus &msgStatus) override;
+ ::ndk::ScopedAStatus closeEndpointSession(int32_t sessionId,
+ Reason reason) override;
+ ::ndk::ScopedAStatus endpointSessionOpenComplete(int32_t sessionId) override;
void onNanoappMessage(const ::chre::fbs::NanoappMessageT &message) override;
@@ -103,6 +133,9 @@
void onDebugDumpComplete(
const ::chre::fbs::DebugDumpResponseT &response) override;
+ bool onContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion &message) override;
+
void handleServiceDeath();
static void onServiceDied(void *cookie);
@@ -238,6 +271,11 @@
ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
+ // Implementation of the V4 API.
+ std::optional<
+ ::android::hardware::contexthub::common::implementation::ContextHubV4Impl>
+ mV4Impl{};
+
std::map<Setting, bool> mSettingEnabled;
std::optional<bool> mIsWifiAvailable;
std::optional<bool> mIsBleAvailable;
diff --git a/host/hal_generic/common/chre_connection_callback.h b/host/hal_generic/common/chre_connection_callback.h
index e751db6..b318836 100644
--- a/host/hal_generic/common/chre_connection_callback.h
+++ b/host/hal_generic/common/chre_connection_callback.h
@@ -32,7 +32,10 @@
/** This method should be called when CHRE is reconnected to HAL and ready to
* accept new messages. */
- virtual void onChreRestarted(){};
+ virtual void onChreRestarted() {};
+
+ /** This method should be called when CHRE is disconnected from HAL. */
+ virtual void onChreDisconnected() {};
};
} // namespace android::hardware::contexthub::common::implementation
#endif // ANDROID_HARDWARE_CONTEXTHUB_COMMON_CHRE_CONNECTION_CALLBACK_H_
\ No newline at end of file
diff --git a/host/hal_generic/common/context_hub_v4_impl.cc b/host/hal_generic/common/context_hub_v4_impl.cc
new file mode 100644
index 0000000..91fdde6
--- /dev/null
+++ b/host/hal_generic/common/context_hub_v4_impl.cc
@@ -0,0 +1,444 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "context_hub_v4_impl.h"
+
+#include <assert.h>
+#include <inttypes.h>
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <aidl/android/hardware/contexthub/BnContextHub.h>
+#include <chre_host/generated/host_messages_generated.h>
+#include <chre_host/log.h>
+
+namespace android::hardware::contexthub::common::implementation {
+
+using ::aidl::android::hardware::contexthub::BnContextHub;
+using ::chre::fbs::ChreMessage;
+using HostHub = MessageHubManager::HostHub;
+
+void ContextHubV4Impl::init() {
+ // TODO(b/378545373): Send message to get hubs/endpoints state dump to
+ // initialize mManager.
+}
+
+namespace {
+
+ScopedAStatus fromPwStatus(pw::Status status) {
+ switch (status.code()) {
+ case PW_STATUS_OK:
+ return ScopedAStatus::ok();
+ case PW_STATUS_NOT_FOUND:
+ [[fallthrough]];
+ case PW_STATUS_ALREADY_EXISTS:
+ [[fallthrough]];
+ case PW_STATUS_OUT_OF_RANGE:
+ [[fallthrough]];
+ case PW_STATUS_PERMISSION_DENIED:
+ [[fallthrough]];
+ case PW_STATUS_INVALID_ARGUMENT:
+ return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+ case PW_STATUS_UNIMPLEMENTED:
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+ default:
+ return ScopedAStatus::fromServiceSpecificError(
+ BnContextHub::EX_CONTEXT_HUB_UNSPECIFIED);
+ }
+}
+
+} // namespace
+
+ScopedAStatus ContextHubV4Impl::getHubs(std::vector<HubInfo> *hubs) {
+ *hubs = mManager.getEmbeddedHubs();
+ return ScopedAStatus::ok();
+}
+
+ScopedAStatus ContextHubV4Impl::getEndpoints(
+ std::vector<EndpointInfo> *endpoints) {
+ *endpoints = mManager.getEmbeddedEndpoints();
+ return ScopedAStatus::ok();
+}
+
+ScopedAStatus ContextHubV4Impl::registerEndpoint(const EndpointInfo &endpoint) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->addEndpoint(hub, endpoint); !status.ok()) {
+ LOGE("Failed to register endpoint %" PRId64 " on hub %" PRId64
+ " with %" PRId32,
+ endpoint.id.id, hub->id(), status.code());
+ return fromPwStatus(status);
+ }
+ // TODO(b/378545373): Send the endpoint info to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::unregisterEndpoint(
+ const EndpointInfo &endpoint) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->removeEndpoint(endpoint.id); !status.ok()) {
+ LOGE("Failed to unregister endpoint %" PRId32 " on hub %" PRId32
+ " with %" PRId32,
+ endpoint.id.id, hub->id(), status.code());
+ return fromPwStatus(status);
+ }
+ // TODO(b/378545373): Send the endpoint info to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ return fromPwStatus(hub->setCallback(callback));
+}
+
+ScopedAStatus ContextHubV4Impl::requestSessionIdRange(
+ int32_t size, std::vector<int32_t> *ids) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ auto statusOrRange = hub->reserveSessionIdRange(size);
+ if (!statusOrRange.ok()) {
+ LOGE("Failed to reserve %" PRId32 " session ids on hub %" PRId64
+ " with %" PRId32,
+ size, hub->id(), statusOrRange.status().code());
+ return fromPwStatus(statusOrRange.status());
+ }
+ ids->resize(2);
+ (*ids)[0] = statusOrRange->first;
+ (*ids)[1] = statusOrRange->second;
+ return ScopedAStatus::ok();
+}
+
+ScopedAStatus ContextHubV4Impl::openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> & /*serviceDescriptor*/) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ pw::Result<std::shared_ptr<HostHub>> statusOrPruneHub =
+ hub->openSession(hub, initiator, destination, sessionId);
+ if (!statusOrPruneHub.ok()) {
+ LOGE("Failed to open session %" PRId32 " from (%" PRId64 ", %" PRId64
+ ") to (%" PRId64 ", %" PRId64 ") with %" PRId32,
+ sessionId, initiator.hubId, initiator.id, destination.hubId,
+ destination.id, statusOrPruneHub.status().code());
+ return fromPwStatus(statusOrPruneHub.status());
+ } else if (*statusOrPruneHub) {
+ // Send a closed session notification on the hub that hosted the pruned
+ // session.
+ auto status = (*statusOrPruneHub)->closeSession(sessionId);
+ LOGD("Pruning session %" PRIu16 " with status %" PRId32, sessionId,
+ status.code());
+ }
+ // TODO(b/378545373): Send the session open request to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::sendMessageToEndpoint(int32_t sessionId,
+ const Message & /*msg*/) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->checkSessionOpen(sessionId); !status.ok()) {
+ if (status.IsUnavailable()) {
+ hub->getCallback()->onCloseEndpointSession(sessionId,
+ Reason::ENDPOINT_GONE);
+ } else {
+ LOGE("Failed to verify session %" PRId32 " on hub %" PRId64
+ " with %" PRId32,
+ sessionId, hub->id(), status.code());
+ }
+ return fromPwStatus(status);
+ }
+ // TODO(b/378545373): Handle reliable messages.
+ // TODO(b/378545373): Send the message to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus & /*msgStatus*/) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->checkSessionOpen(sessionId); !status.ok()) {
+ if (status.IsUnavailable()) {
+ hub->getCallback()->onCloseEndpointSession(sessionId,
+ Reason::ENDPOINT_GONE);
+ } else {
+ LOGE("Failed to verify session %" PRId32 " on hub %" PRId64
+ " with %" PRId32,
+ sessionId, hub->id(), status.code());
+ }
+ return fromPwStatus(status);
+ }
+ // TODO(b/378545373): Send the message to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::closeEndpointSession(int32_t sessionId,
+ Reason /*reason*/) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->closeSession(sessionId); !status.ok()) {
+ LOGE("Failed to close session %" PRId32 " on hub %" PRId64 " with %" PRId32,
+ sessionId, hub->id(), status.code());
+ return fromPwStatus(status);
+ }
+ hub->getCallback()->onCloseEndpointSession(
+ sessionId, Reason::CLOSE_ENDPOINT_SESSION_REQUESTED);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus ContextHubV4Impl::endpointSessionOpenComplete(int32_t sessionId) {
+ std::shared_ptr<HostHub> hub =
+ mManager.getHostHubByPid(AIBinder_getCallingPid());
+ assert(hub != nullptr);
+ if (auto status = hub->ackSession(sessionId); !status.ok()) {
+ if (status.IsUnavailable()) {
+ hub->getCallback()->onCloseEndpointSession(sessionId,
+ Reason::ENDPOINT_GONE);
+ } else {
+ LOGE("Failed to verify session %" PRId32 " on hub %" PRId64
+ " with %" PRId32,
+ sessionId, hub->id(), status.code());
+ }
+ return fromPwStatus(status);
+ }
+ // TODO(b/378545373): Send the session id to CHRE.
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+bool ContextHubV4Impl::handleMessageFromChre(
+ const ::chre::fbs::ChreMessageUnion &message) {
+ switch (message.type) {
+ case ChreMessage::GetMessageHubsAndEndpointsResponse:
+ onGetMessageHubsAndEndpointsResponse(
+ *message.AsGetMessageHubsAndEndpointsResponse());
+ break;
+ case ChreMessage::RegisterMessageHub:
+ onRegisterMessageHub(*message.AsRegisterMessageHub());
+ break;
+ case ChreMessage::UnregisterMessageHub:
+ onUnregisterMessageHub(*message.AsUnregisterMessageHub());
+ break;
+ case ChreMessage::RegisterEndpoint:
+ onRegisterEndpoint(*message.AsRegisterEndpoint());
+ break;
+ case ChreMessage::OpenEndpointSessionRequest:
+ onOpenEndpointSessionRequest(*message.AsOpenEndpointSessionRequest());
+ break;
+ case ChreMessage::EndpointSessionOpened:
+ onEndpointSessionOpened(*message.AsEndpointSessionOpened());
+ break;
+ case ChreMessage::EndpointSessionClosed:
+ onEndpointSessionClosed(*message.AsEndpointSessionClosed());
+ break;
+ case ChreMessage::EndpointSessionMessage:
+ onEndpointSessionMessage(*message.AsEndpointSessionMessage());
+ break;
+ case ChreMessage::EndpointSessionMessageDeliveryStatus:
+ onEndpointSessionMessageDeliveryStatus(
+ *message.AsEndpointSessionMessageDeliveryStatus());
+ break;
+ default:
+ LOGW("Got unexpected message type %" PRIu8,
+ static_cast<uint8_t>(message.type));
+ return false;
+ }
+ return true;
+}
+
+void ContextHubV4Impl::onGetMessageHubsAndEndpointsResponse(
+ const ::chre::fbs::GetMessageHubsAndEndpointsResponseT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ std::vector<HubInfo> hubs;
+ std::vector<EndpointInfo> endpoints;
+ LOGI("Initializing embedded message hub cache");
+ mManager.initEmbeddedHubsAndEndpoints(hubs, endpoints);
+}
+
+void ContextHubV4Impl::onRegisterMessageHub(
+ const ::chre::fbs::RegisterMessageHubT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ HubInfo hub;
+ LOGI("Embedded message hub %" PRId64 " registered", hub.hubId);
+ mManager.addEmbeddedHub(hub);
+}
+
+void ContextHubV4Impl::onUnregisterMessageHub(
+ const ::chre::fbs::UnregisterMessageHubT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ int64_t id = 0;
+ LOGI("Embedded message hub %" PRId64 " unregistered", id);
+ std::vector<EndpointId> endpoints = mManager.removeEmbeddedHub(id);
+ if (!endpoints.empty()) {
+ mManager.forEachHostHub([&endpoints](HostHub &hub) {
+ hub.getCallback()->onEndpointStopped(endpoints, Reason::HUB_RESET);
+ });
+ }
+}
+
+void ContextHubV4Impl::onRegisterEndpoint(
+ const ::chre::fbs::RegisterEndpointT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ EndpointInfo endpoint;
+ LOGI("Adding embedded endpoint (%" PRId64 ", %" PRId64 ")", endpoint.id.hubId,
+ endpoint.id.id);
+ mManager.addEmbeddedEndpoint(endpoint);
+ mManager.forEachHostHub([&endpoint](HostHub &hub) {
+ hub.getCallback()->onEndpointStarted({endpoint});
+ });
+}
+
+void ContextHubV4Impl::onUnregisterEndpoint(
+ const ::chre::fbs::UnregisterEndpointT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ EndpointId endpoint;
+ LOGI("Removing embedded endpoint (%" PRId64 ", %" PRId64 ")", endpoint.hubId,
+ endpoint.id);
+ mManager.removeEmbeddedEndpoint(endpoint);
+ mManager.forEachHostHub([&endpoint](HostHub &hub) {
+ hub.getCallback()->onEndpointStopped({endpoint}, Reason::ENDPOINT_GONE);
+ });
+}
+
+void ContextHubV4Impl::onOpenEndpointSessionRequest(
+ const ::chre::fbs::OpenEndpointSessionRequestT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ std::optional<std::string> serviceDescriptor;
+ EndpointId local, remote;
+ uint16_t sessionId = 0;
+ LOGD("New session (%" PRIu16 ") request from (%" PRId64 ", %" PRId64
+ ") to "
+ "(%" PRId64 ", %" PRId64 ")",
+ sessionId, remote.hubId, remote.id, local.hubId, local.id);
+
+ // Look up the host hub based on the host endpoint.
+ std::shared_ptr<HostHub> hub = mManager.getHostHubByEndpointId(local);
+ if (!hub) {
+ LOGW("Unable to find host hub");
+ return;
+ }
+
+ // Record the open session request and pass it on to the appropriate client.
+ auto statusOrPruneHub = hub->openSession(hub, local, remote, sessionId);
+ if (!statusOrPruneHub.ok()) {
+ LOGE("Failed to request session %" PRIu16 " with %" PRId32, sessionId,
+ statusOrPruneHub.status().code());
+ return;
+ } else if (*statusOrPruneHub) {
+ // Send a closed session notification on the hub that hosted the pruned
+ // session.
+ auto status = (*statusOrPruneHub)->closeSession(sessionId);
+ LOGD("Pruning session %" PRIu16 " with status %" PRId32, sessionId,
+ status.code());
+ }
+ hub->getCallback()->onEndpointSessionOpenRequest(
+ sessionId, local, remote, std::move(serviceDescriptor));
+}
+
+namespace {
+
+void logGetHubFailure(pw::Status status, int32_t sessionId) {
+ if (status.IsUnavailable()) {
+ LOGD("Session %" PRId32 " was pruned.", sessionId);
+ } else {
+ LOGE("Failed to operate on session %" PRId32 " with %" PRId32, sessionId,
+ status.code());
+ }
+}
+
+} // namespace
+
+void ContextHubV4Impl::onEndpointSessionOpened(
+ const ::chre::fbs::EndpointSessionOpenedT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ int32_t id = 0;
+ LOGD("New session ack for id %" PRId32, id);
+ auto statusOrHub = mManager.ackSessionAndGetHostHub(id);
+ if (!statusOrHub.ok()) {
+ logGetHubFailure(statusOrHub.status(), id);
+ // TODO(b/378545373): Send a notification back to CHRE.
+ return;
+ }
+
+ // Only send a session open complete message to the host hub client if it was
+ // the initiator.
+ if (static_cast<uint16_t>(id) >= MessageHubManager::kHostSessionIdBase)
+ (*statusOrHub)->getCallback()->onEndpointSessionOpenComplete(id);
+}
+
+void ContextHubV4Impl::onEndpointSessionClosed(
+ const ::chre::fbs::EndpointSessionClosedT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ int32_t id = 0;
+ Reason reason = Reason::UNSPECIFIED;
+ LOGD("Closing session id %" PRId32 " for %" PRIu8, id, reason);
+ auto statusOrHub = mManager.checkSessionOpenAndGetHostHub(id);
+ if (!statusOrHub.ok()) {
+ logGetHubFailure(statusOrHub.status(), id);
+ return;
+ }
+ (*statusOrHub)->getCallback()->onCloseEndpointSession(id, reason);
+}
+
+void ContextHubV4Impl::onEndpointSessionMessage(
+ const ::chre::fbs::EndpointSessionMessageT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ Message message;
+ int32_t sessionId = 0;
+ auto statusOrHub = mManager.checkSessionOpenAndGetHostHub(sessionId);
+ if (!statusOrHub.ok()) {
+ logGetHubFailure(statusOrHub.status(), sessionId);
+ // TODO(b/378545373): Send a notification back to CHRE.
+ return;
+ }
+ (*statusOrHub)->getCallback()->onMessageReceived(sessionId, message);
+}
+
+void ContextHubV4Impl::onEndpointSessionMessageDeliveryStatus(
+ const ::chre::fbs::EndpointSessionMessageDeliveryStatusT & /*msg*/) {
+ // TODO(b/378545373): Parse flatbuffer message
+ MessageDeliveryStatus status;
+ int32_t sessionId = 0;
+ auto statusOrHub = mManager.checkSessionOpenAndGetHostHub(sessionId);
+ if (!statusOrHub.ok()) {
+ logGetHubFailure(statusOrHub.status(), sessionId);
+ // TODO(b/378545373): Send a notification back to CHRE.
+ return;
+ }
+ // TODO(b/378545373): Handle reliable messages.
+ (*statusOrHub)
+ ->getCallback()
+ ->onMessageDeliveryStatusReceived(sessionId, status);
+}
+
+void ContextHubV4Impl::onHostHubDown(int64_t /*id*/) {
+ // TODO(b/378545373): Send an UnregisterMessageHub message to CHRE with id.
+}
+
+} // namespace android::hardware::contexthub::common::implementation
diff --git a/host/hal_generic/common/context_hub_v4_impl.h b/host/hal_generic/common/context_hub_v4_impl.h
new file mode 100644
index 0000000..b07dc34
--- /dev/null
+++ b/host/hal_generic/common/context_hub_v4_impl.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <aidl/android/hardware/contexthub/BnContextHub.h>
+#include <chre_host/generated/host_messages_generated.h>
+
+#include "message_hub_manager.h"
+
+namespace android::hardware::contexthub::common::implementation {
+
+using ::aidl::android::hardware::contexthub::EndpointId;
+using ::aidl::android::hardware::contexthub::EndpointInfo;
+using ::aidl::android::hardware::contexthub::HubInfo;
+using ::aidl::android::hardware::contexthub::IEndpointCallback;
+using ::aidl::android::hardware::contexthub::Message;
+using ::aidl::android::hardware::contexthub::MessageDeliveryStatus;
+using ::aidl::android::hardware::contexthub::Reason;
+using ::ndk::ScopedAStatus;
+
+class ContextHubV4Impl {
+ public:
+ using SendMessageFn = std::function<bool(uint8_t *data, size_t size)>;
+
+ explicit ContextHubV4Impl(SendMessageFn sendMessageFn)
+ : mManager([this](int64_t id) { onHostHubDown(id); }),
+ mSendMessageFn(std::move(sendMessageFn)) {}
+ ~ContextHubV4Impl() = default;
+
+ /**
+ * Initializes the implementation.
+ *
+ * This should be called once a connection with CHRE has been established.
+ * Requests a dump of embedded hubs and endpoints from CHRE.
+ */
+ void init();
+
+ // ContextHub V4 API implementation.
+ ScopedAStatus getHubs(std::vector<HubInfo> *hubs);
+ ScopedAStatus getEndpoints(std::vector<EndpointInfo> *endpoints);
+ ScopedAStatus registerEndpoint(const EndpointInfo &endpoint);
+ ScopedAStatus unregisterEndpoint(const EndpointInfo &endpoint);
+ ScopedAStatus registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback);
+ ScopedAStatus requestSessionIdRange(int32_t size, std::vector<int32_t> *ids);
+ ScopedAStatus openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> &serviceDescriptor);
+ ScopedAStatus sendMessageToEndpoint(int32_t sessionId, const Message &msg);
+ ScopedAStatus sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus &msgStatus);
+ ScopedAStatus closeEndpointSession(int32_t sessionId, Reason reason);
+ ScopedAStatus endpointSessionOpenComplete(int32_t sessionId);
+
+ /**
+ * Handles a CHRE message that is part of the V4 implementation.
+ *
+ * @param message Validated union of the various message types.
+ * @return true if the message could be handled
+ */
+ bool handleMessageFromChre(const ::chre::fbs::ChreMessageUnion &message);
+
+ private:
+ // Callbacks for each message type from CHRE.
+ void onGetMessageHubsAndEndpointsResponse(
+ const ::chre::fbs::GetMessageHubsAndEndpointsResponseT &msg);
+ void onRegisterMessageHub(const ::chre::fbs::RegisterMessageHubT &msg);
+ void onUnregisterMessageHub(const ::chre::fbs::UnregisterMessageHubT &msg);
+ void onRegisterEndpoint(const ::chre::fbs::RegisterEndpointT &msg);
+ void onUnregisterEndpoint(const ::chre::fbs::UnregisterEndpointT &msg);
+ void onOpenEndpointSessionRequest(
+ const ::chre::fbs::OpenEndpointSessionRequestT &msg);
+ void onEndpointSessionOpened(const ::chre::fbs::EndpointSessionOpenedT &msg);
+ void onEndpointSessionClosed(const ::chre::fbs::EndpointSessionClosedT &msg);
+ void onEndpointSessionMessage(
+ const ::chre::fbs::EndpointSessionMessageT &msg);
+ void onEndpointSessionMessageDeliveryStatus(
+ const ::chre::fbs::EndpointSessionMessageDeliveryStatusT &msg);
+
+ // Callback invoked when a HAL client associated with a host hub goes down.
+ void onHostHubDown(int64_t id);
+
+ MessageHubManager mManager;
+ SendMessageFn mSendMessageFn;
+};
+
+} // namespace android::hardware::contexthub::common::implementation
diff --git a/host/hal_generic/common/generic_context_hub_base.h b/host/hal_generic/common/generic_context_hub_base.h
index 64b4a24..b7513d5 100644
--- a/host/hal_generic/common/generic_context_hub_base.h
+++ b/host/hal_generic/common/generic_context_hub_base.h
@@ -350,6 +350,11 @@
debugDumpComplete();
}
+ bool onContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion & /* message */) override {
+ return false;
+ }
+
// Write a string to the debug file.
void writeToDebugFile(const char *str) override {
if (checkDebugFd()) {
diff --git a/host/hal_generic/common/hal_chre_socket_connection.cc b/host/hal_generic/common/hal_chre_socket_connection.cc
index 4d6b7b7..1c72bde 100644
--- a/host/hal_generic/common/hal_chre_socket_connection.cc
+++ b/host/hal_generic/common/hal_chre_socket_connection.cc
@@ -146,6 +146,10 @@
return mClient.sendMessage(builder.GetBufferPointer(), builder.GetSize());
}
+bool HalChreSocketConnection::sendRawMessage(uint8_t *data, size_t size) {
+ return mClient.sendMessage(data, size);
+}
+
bool HalChreSocketConnection::sendSettingChangedNotification(
::chre::fbs::Setting fbsSetting, ::chre::fbs::SettingState fbsState) {
FlatBufferBuilder builder(64);
@@ -312,6 +316,11 @@
mCallback->onDebugDumpComplete(response);
}
+bool HalChreSocketConnection::SocketCallbacks::handleContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion &message) {
+ return mCallback->onContextHubV4Message(message);
+}
+
bool HalChreSocketConnection::isExpectedLoadResponseLocked(
const ::chre::fbs::LoadNanoappResponseT &response) {
return mPendingLoadTransaction.has_value() &&
diff --git a/host/hal_generic/common/hal_chre_socket_connection.h b/host/hal_generic/common/hal_chre_socket_connection.h
index 5a3be43..a62ced8 100644
--- a/host/hal_generic/common/hal_chre_socket_connection.h
+++ b/host/hal_generic/common/hal_chre_socket_connection.h
@@ -89,6 +89,15 @@
*/
virtual void onDebugDumpComplete(
const ::chre::fbs::DebugDumpResponseT &response) = 0;
+
+ /**
+ * Handles a ContextHub V4+ message or returns false.
+ *
+ * @param message The union of possible messages.
+ * @return true on successful handling
+ */
+ virtual bool onContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion &message) = 0;
};
/**
@@ -117,6 +126,8 @@
bool sendSettingChangedNotification(::chre::fbs::Setting fbsSetting,
::chre::fbs::SettingState fbsState);
+ bool sendRawMessage(uint8_t *data, size_t size);
+
bool onHostEndpointConnected(uint16_t hostEndpointId, uint8_t type,
const std::string &package_name,
const std::string &attribution_tag);
@@ -155,6 +166,8 @@
void handleDebugDumpData(const ::chre::fbs::DebugDumpDataT &data) override;
void handleDebugDumpResponse(
const ::chre::fbs::DebugDumpResponseT &response) override;
+ bool handleContextHubV4Message(
+ const ::chre::fbs::ChreMessageUnion &message) override;
private:
HalChreSocketConnection &mParent;
diff --git a/host/hal_generic/common/hal_client_manager.cc b/host/hal_generic/common/hal_client_manager.cc
index ec75fdc..f300cde 100644
--- a/host/hal_generic/common/hal_client_manager.cc
+++ b/host/hal_generic/common/hal_client_manager.cc
@@ -554,13 +554,20 @@
}
void HalClientManager::handleChreRestart() {
+ const std::lock_guard<std::mutex> lock(mLock);
+ mPendingLoadTransaction.reset();
+ mPendingUnloadTransaction.reset();
+ for (Client &client : mClients) {
+ client.endpointIds.clear();
+ }
+}
+
+std::vector<std::shared_ptr<IContextHubCallback>>
+HalClientManager::getCallbacks() {
std::vector<std::shared_ptr<IContextHubCallback>> callbacks;
{
const std::lock_guard<std::mutex> lock(mLock);
- mPendingLoadTransaction.reset();
- mPendingUnloadTransaction.reset();
for (Client &client : mClients) {
- client.endpointIds.clear();
if (client.callback != nullptr) {
// Create a copy of the callback and call it later without holding the
// lock to avoid deadlocks.
@@ -568,10 +575,7 @@
}
}
}
-
- for (const auto &callback : callbacks) {
- callback->handleContextHubAsyncEvent(AsyncEventType::RESTARTED);
- }
+ return callbacks;
}
void HalClientManager::updateClientIdMappingFile() {
diff --git a/host/hal_generic/common/hal_client_manager.h b/host/hal_generic/common/hal_client_manager.h
index 0073da2..5dec2e3 100644
--- a/host/hal_generic/common/hal_client_manager.h
+++ b/host/hal_generic/common/hal_client_manager.h
@@ -65,7 +65,7 @@
* identifies a host app that communicates with a HAL client.
*
* For a host endpoint connected to ContextHubService, its endpoint id is kept
- *in the form below during the communication with CHRE.
+ * in the form below during the communication with CHRE.
*
* 0 1
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
@@ -182,6 +182,13 @@
std::shared_ptr<IContextHubCallback> getCallback(HalClientId clientId);
/**
+ * Gets all the callbacks and postpone any API calls to the caller.
+ *
+ * @return all the non-null callback pointers
+ */
+ std::vector<std::shared_ptr<IContextHubCallback>> getCallbacks();
+
+ /**
* Registers a IContextHubCallback function mapped to the current client's
* client id. @p deathRecipient and @p deathRecipientCookie are used to unlink
* the previous registered callback for the same client, if any.
diff --git a/host/hal_generic/common/message_hub_manager.cc b/host/hal_generic/common/message_hub_manager.cc
new file mode 100644
index 0000000..6306eca
--- /dev/null
+++ b/host/hal_generic/common/message_hub_manager.cc
@@ -0,0 +1,444 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "message_hub_manager.h"
+
+#include <unistd.h>
+
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <aidl/android/hardware/contexthub/BnContextHub.h>
+
+#include "chre_host/log.h"
+#include "pw_result/result.h"
+#include "pw_status/status.h"
+#include "pw_status/try.h"
+
+namespace android::hardware::contexthub::common::implementation {
+
+using HostHub = MessageHubManager::HostHub;
+
+HostHub::~HostHub() {
+ std::lock_guard lock(mManager.mLock);
+ unlinkCallbackIfNecessaryLocked();
+}
+
+pw::Status HostHub::setCallback(std::shared_ptr<IEndpointCallback> callback) {
+ std::lock_guard lock(mManager.mLock);
+ auto *cookie = new DeathRecipientCookie{&mManager, kPid};
+ if (AIBinder_linkToDeath(callback->asBinder().get(),
+ mManager.mDeathRecipient.get(),
+ cookie) != STATUS_OK) {
+ LOGE("Failed to link callback for hub %ld (pid %d) to death recipient", kId,
+ kPid);
+ delete cookie;
+ return pw::Status::Internal();
+ }
+ unlinkCallbackIfNecessaryLocked();
+ mCallback = std::move(callback);
+ mCookie = cookie;
+ return pw::OkStatus();
+}
+
+std::shared_ptr<IEndpointCallback> HostHub::getCallback() const {
+ std::lock_guard lock(mManager.mLock);
+ return mCallback;
+}
+
+pw::Status HostHub::addEndpoint(std::weak_ptr<HostHub> self,
+ const EndpointInfo &info) {
+ std::lock_guard lock(mManager.mLock);
+ PW_TRY(checkValidLocked());
+ int64_t id = info.id.id;
+ if (auto it = mIdToEndpoint.find(id); it != mIdToEndpoint.end()) {
+ LOGE("Endpoint %ld already exists in hub %ld (pid %d)", id, kId, kPid);
+ return pw::Status::AlreadyExists();
+ }
+ if (kId == kHubIdInvalid) {
+ // If this is the hub's first endpoint, store its hub id and register it
+ // with the manager.
+ if (info.id.hubId == kContextHubServiceHubId &&
+ AIBinder_getCallingUid() != kSystemServerUid) {
+ LOGW(
+ "Non-systemserver client (pid %d) trying to register as "
+ "ContextHubService",
+ kPid);
+ return pw::Status::InvalidArgument();
+ }
+ kId = info.id.hubId;
+ mManager.mIdToHostHub.insert({kId, self});
+ }
+ mIdToEndpoint.insert({id, std::make_unique<EndpointInfo>(info)});
+ return pw::OkStatus();
+}
+
+pw::Status HostHub::removeEndpoint(const EndpointId &id) {
+ std::lock_guard lock(mManager.mLock);
+ PW_TRY(checkValidLocked());
+ if (auto it = mIdToEndpoint.find(id.id); it != mIdToEndpoint.end()) {
+ mIdToEndpoint.erase(it);
+ return pw::OkStatus();
+ }
+ LOGE("Client (hub %ld, pid %d) tried to remove unknown endpoint %ld", kId,
+ kPid, id.id);
+ return pw::Status::NotFound();
+}
+
+pw::Result<std::pair<uint16_t, uint16_t>> HostHub::reserveSessionIdRange(
+ uint16_t size) {
+ std::lock_guard lock(mManager.mLock);
+ PW_TRY(checkValidLocked());
+ if (!size || size > kSessionIdMaxRange) {
+ LOGE("Client (hub %ld, pid %d) tried to allocate %hu session ids", kId,
+ kPid, size);
+ return pw::Status::InvalidArgument();
+ }
+ if (USHRT_MAX - mManager.mNextSessionId + 1 < size) {
+ LOGW("Could not allocate %hu session ids, ids exhausted", size);
+ return pw::Status::ResourceExhausted();
+ }
+ mSessionIdRanges.push_back(
+ {mManager.mNextSessionId, mManager.mNextSessionId + size - 1});
+ mManager.mNextSessionId += size;
+ return mSessionIdRanges.back();
+}
+
+pw::Result<std::shared_ptr<HostHub>> HostHub::openSession(
+ std::weak_ptr<HostHub> self, const EndpointId &localId,
+ const EndpointId &remoteId, uint16_t sessionId) {
+ std::lock_guard lock(mManager.mLock);
+ PW_TRY(checkValidLocked());
+
+ // Lookup the endpoints.
+ PW_TRY_ASSIGN(std::shared_ptr<EndpointInfo> local,
+ getEndpointLocked(localId));
+ PW_TRY_ASSIGN(std::shared_ptr<EndpointInfo> remote,
+ mManager.getEmbeddedEndpointLocked(remoteId));
+
+ // Validate the session id.
+ bool hostInitiated = AIBinder_isHandlingTransaction();
+ if (hostInitiated) {
+ if (!sessionIdInRangeLocked(sessionId)) {
+ LOGE("Session id %hu out of range for hub %ld", sessionId, kId);
+ return pw::Status::OutOfRange();
+ }
+ } else if (sessionId >= kHostSessionIdBase) {
+ LOGE(
+ "Remote endpoint (%ld, %ld) attempting to start session with "
+ "invalid id %hu",
+ remoteId.hubId, remoteId.id, sessionId);
+ return pw::Status::InvalidArgument();
+ }
+
+ // Prune a stale session with this id if present.
+ std::shared_ptr<HostHub> prunedHostHub;
+ if (auto it = mManager.mIdToSession.find(sessionId);
+ it != mManager.mIdToSession.end()) {
+ SessionStrongRef session(it->second);
+ if (session) {
+ // If the session is in a valid state, prune it if it was not host
+ // initiated and is pending a final ack from message router.
+ if (!hostInitiated && !session.pendingDestination &&
+ session.pendingMessageRouter) {
+ prunedHostHub = std::move(session.hub);
+ } else if (hostInitiated && session.local->id == localId) {
+ LOGE("Hub %ld trying to override its own session %hu", kId, sessionId);
+ return pw::Status::InvalidArgument();
+ } else {
+ LOGE("(host? %d) trying to override session id %hu, hub %ld",
+ hostInitiated, sessionId, kId);
+ return pw::Status::AlreadyExists();
+ }
+ }
+ mManager.mIdToSession.erase(it);
+ }
+
+ // Create and map the new session.
+ mManager.mIdToSession.emplace(
+ std::piecewise_construct, std::forward_as_tuple(sessionId),
+ std::forward_as_tuple(self, local, remote, hostInitiated));
+ return prunedHostHub;
+}
+
+pw::Status HostHub::closeSession(uint16_t id) {
+ std::lock_guard lock(mManager.mLock);
+ PW_TRY(checkValidLocked());
+ auto it = mManager.mIdToSession.find(id);
+ if (it == mManager.mIdToSession.end()) {
+ LOGE("Closing unopened session %hu", id);
+ return pw::Status::NotFound();
+ }
+ SessionStrongRef session(it->second);
+ if (session && session.hub->kPid != kPid) {
+ LOGE("Trying to close session %hu for client %d from client %d (hub %ld)",
+ id, session.hub->kPid, kPid, kId);
+ return pw::Status::PermissionDenied();
+ }
+ mManager.mIdToSession.erase(it);
+ return pw::OkStatus();
+}
+
+pw::Status HostHub::ackSession(uint16_t id) {
+ return mManager.ackSessionAndGetHostHub(id).status();
+}
+
+pw::Status HostHub::checkSessionOpen(uint16_t id) {
+ return mManager.checkSessionOpenAndGetHostHub(id).status();
+}
+
+int64_t HostHub::id() const {
+ std::lock_guard lock(mManager.mLock);
+ return kId;
+}
+
+int64_t MessageHubManager::HostHub::unlinkFromManager() {
+ std::lock_guard lock(mManager.mLock);
+ // TODO(b/378545373): Release the session id range.
+ if (kId != kHubIdInvalid) mManager.mIdToHostHub.erase(kId);
+ mManager.mPidToHostHub.erase(kPid);
+ mUnlinked = true;
+ return kId;
+}
+
+void HostHub::unlinkCallbackIfNecessaryLocked() {
+ if (!mCallback) return;
+ if (AIBinder_unlinkToDeath(mCallback->asBinder().get(),
+ mManager.mDeathRecipient.get(),
+ mCookie) != STATUS_OK) {
+ LOGW("Failed to unlink client (pid: %d, hub id: %ld)", kPid, kId);
+ }
+ mCallback.reset();
+ mCookie = nullptr;
+}
+
+pw::Status HostHub::checkValidLocked() {
+ if (!mCallback) {
+ ALOGW("Endpoint APIs invoked by client %d before callback registered",
+ kPid);
+ return pw::Status::FailedPrecondition();
+ } else if (mUnlinked) {
+ ALOGW("Client %d went down mid-operation", kPid);
+ return pw::Status::Aborted();
+ }
+ return pw::OkStatus();
+}
+
+pw::Result<std::shared_ptr<EndpointInfo>> HostHub::getEndpointLocked(
+ const EndpointId &id) {
+ if (id.hubId != kId) {
+ LOGE("Rejecting lookup on unowned endpoint (%ld, %ld) from hub %ld",
+ id.hubId, id.id, kId);
+ return pw::Status::InvalidArgument();
+ }
+ if (auto it = mIdToEndpoint.find(id.id); it != mIdToEndpoint.end())
+ return it->second;
+ return pw::Status::NotFound();
+}
+
+bool HostHub::sessionIdInRangeLocked(uint16_t id) {
+ for (auto range : mSessionIdRanges) {
+ if (id >= range.first && id <= range.second) return true;
+ }
+ return false;
+}
+
+MessageHubManager::MessageHubManager(HostHubDownCb cb)
+ : mHostHubDownCb(std::move(cb)) {
+ mDeathRecipient = ndk::ScopedAIBinder_DeathRecipient(
+ AIBinder_DeathRecipient_new(onClientDeath));
+ AIBinder_DeathRecipient_setOnUnlinked(
+ mDeathRecipient.get(), /*onUnlinked= */ [](void *cookie) {
+ LOGI("Callback is unlinked. Releasing the death recipient cookie.");
+ delete static_cast<HostHub::DeathRecipientCookie *>(cookie);
+ });
+}
+
+std::shared_ptr<HostHub> MessageHubManager::getHostHubByPid(pid_t pid) {
+ std::lock_guard lock(mLock);
+ if (auto it = mPidToHostHub.find(pid); it != mPidToHostHub.end())
+ return it->second;
+ std::shared_ptr<HostHub> hub(new HostHub(*this, pid));
+ mPidToHostHub.insert({pid, hub});
+ return hub;
+}
+
+std::shared_ptr<HostHub> MessageHubManager::getHostHubByEndpointId(
+ const EndpointId &id) {
+ std::lock_guard lock(mLock);
+ if (auto it = mIdToHostHub.find(id.hubId); it != mIdToHostHub.end())
+ return it->second.lock();
+ return {};
+}
+
+pw::Result<std::shared_ptr<HostHub>>
+MessageHubManager::checkSessionOpenAndGetHostHub(uint16_t id) {
+ std::lock_guard lock(mLock);
+ PW_TRY_ASSIGN(SessionStrongRef session, checkSessionLocked(id));
+ if (AIBinder_getCallingPid() != session.hub->kPid) {
+ LOGE("Trying to check unowned session %hu", id);
+ return pw::Status::PermissionDenied();
+ }
+ if (!session.pendingDestination && !session.pendingMessageRouter)
+ return std::move(session.hub);
+ LOGE("Session %hu is pending", id);
+ return pw::Status::FailedPrecondition();
+}
+
+pw::Result<std::shared_ptr<HostHub>> MessageHubManager::ackSessionAndGetHostHub(
+ uint16_t id) {
+ std::lock_guard lock(mLock);
+ PW_TRY_ASSIGN(SessionStrongRef session, checkSessionLocked(id));
+ bool isBinderCall = AIBinder_isHandlingTransaction();
+ bool isHostSession = id >= kHostSessionIdBase;
+ if (isBinderCall && AIBinder_getCallingPid() != session.hub->kPid) {
+ LOGE("Trying to ack unowned session %hu", id);
+ return pw::Status::PermissionDenied();
+ } else if (session.pendingDestination) {
+ if (isHostSession == isBinderCall) {
+ LOGE("Session %hu must be acked by other side (host? %d)", id,
+ !isBinderCall);
+ return pw::Status::PermissionDenied();
+ }
+ session.pendingDestination = false;
+ } else if (session.pendingMessageRouter) {
+ if (isBinderCall) {
+ LOGE("Message router must ack session %hu", id);
+ return pw::Status::PermissionDenied();
+ }
+ session.pendingMessageRouter = false;
+ } else {
+ LOGE("Received unexpected ack on session %hu, host: %d", id, isBinderCall);
+ }
+ return std::move(session.hub);
+}
+
+void MessageHubManager::forEachHostHub(std::function<void(HostHub &hub)> fn) {
+ std::list<std::shared_ptr<HostHub>> hubs;
+ {
+ std::lock_guard lock(mLock);
+ for (auto &[pid, hub] : mPidToHostHub) hubs.push_back(hub);
+ }
+ for (auto &hub : hubs) fn(*hub);
+}
+
+pw::Result<MessageHubManager::SessionStrongRef>
+MessageHubManager::checkSessionLocked(uint16_t id) {
+ auto sessionIt = mIdToSession.find(id);
+ if (sessionIt == mIdToSession.end()) {
+ LOGE("Did not find expected session %hu", id);
+ return pw::Status::NotFound();
+ }
+ SessionStrongRef session(sessionIt->second);
+ if (!session) {
+ LOGD(
+ "Pruning session %hu due to one or more of host hub, host endpoint, "
+ "or embedded endpoint going down.",
+ id);
+ mIdToSession.erase(sessionIt);
+ return pw::Status::Unavailable();
+ }
+ return std::move(session);
+}
+
+void MessageHubManager::initEmbeddedHubsAndEndpoints(
+ const std::vector<HubInfo> &hubs,
+ const std::vector<EndpointInfo> &endpoints) {
+ std::lock_guard lock(mLock);
+ mIdToEmbeddedHub.clear();
+ for (const auto &hub : hubs) mIdToEmbeddedHub[hub.hubId].info = hub;
+ for (const auto &endpoint : endpoints) addEmbeddedEndpointLocked(endpoint);
+}
+
+void MessageHubManager::addEmbeddedHub(const HubInfo &hub) {
+ std::lock_guard lock(mLock);
+ if (mIdToEmbeddedHub.count(hub.hubId)) return;
+ mIdToEmbeddedHub[hub.hubId].info = hub;
+}
+
+std::vector<EndpointId> MessageHubManager::removeEmbeddedHub(int64_t id) {
+ std::lock_guard lock(mLock);
+ std::vector<EndpointId> endpoints;
+ auto it = mIdToEmbeddedHub.find(id);
+ if (it != mIdToEmbeddedHub.end()) {
+ for (const auto &[endpointId, info] : it->second.idToEndpoint)
+ endpoints.push_back({.id = endpointId, .hubId = id});
+ mIdToEmbeddedHub.erase(it);
+ }
+ return endpoints;
+}
+
+std::vector<HubInfo> MessageHubManager::getEmbeddedHubs() const {
+ std::lock_guard lock(mLock);
+ std::vector<HubInfo> hubs;
+ for (const auto &[id, hub] : mIdToEmbeddedHub) hubs.push_back(hub.info);
+ return hubs;
+}
+
+void MessageHubManager::addEmbeddedEndpoint(const EndpointInfo &endpoint) {
+ std::lock_guard lock(mLock);
+ addEmbeddedEndpointLocked(endpoint);
+}
+
+std::vector<EndpointInfo> MessageHubManager::getEmbeddedEndpoints() const {
+ std::lock_guard lock(mLock);
+ std::vector<EndpointInfo> endpoints;
+ for (const auto &[id, hub] : mIdToEmbeddedHub) {
+ for (const auto &[endptId, endptInfo] : hub.idToEndpoint)
+ endpoints.push_back(*endptInfo);
+ }
+ return endpoints;
+}
+
+void MessageHubManager::onClientDeath(void *cookie) {
+ auto *cookieData = reinterpret_cast<HostHub::DeathRecipientCookie *>(cookie);
+ MessageHubManager *manager = cookieData->manager;
+ std::shared_ptr<HostHub> hub = manager->getHostHubByPid(cookieData->pid);
+ LOGW("Hub %ld (pid %d) died", hub->id(), cookieData->pid);
+ manager->mHostHubDownCb(hub->unlinkFromManager());
+}
+
+void MessageHubManager::addEmbeddedEndpointLocked(
+ const EndpointInfo &endpoint) {
+ auto it = mIdToEmbeddedHub.find(endpoint.id.hubId);
+ if (it == mIdToEmbeddedHub.end()) {
+ LOGW("Could not find hub %ld for endpoint %ld", endpoint.id.hubId,
+ endpoint.id.id);
+ return;
+ }
+ it->second.idToEndpoint.insert(
+ {endpoint.id.id, std::make_shared<EndpointInfo>(endpoint)});
+}
+
+pw::Result<std::shared_ptr<EndpointInfo>>
+MessageHubManager::getEmbeddedEndpointLocked(const EndpointId &id) {
+ auto hubIt = mIdToEmbeddedHub.find(id.hubId);
+ if (hubIt != mIdToEmbeddedHub.end()) {
+ auto it = hubIt->second.idToEndpoint.find(id.id);
+ if (it != hubIt->second.idToEndpoint.end()) return it->second;
+ }
+ LOGW("Could not find remote endpoint (%ld, %ld)", id.hubId, id.id);
+ return pw::Status::NotFound();
+}
+
+} // namespace android::hardware::contexthub::common::implementation
diff --git a/host/hal_generic/common/message_hub_manager.h b/host/hal_generic/common/message_hub_manager.h
new file mode 100644
index 0000000..5353375
--- /dev/null
+++ b/host/hal_generic/common/message_hub_manager.h
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <unistd.h>
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <aidl/android/hardware/contexthub/BnContextHub.h>
+#include <android-base/thread_annotations.h>
+
+#include "pw_result/result.h"
+#include "pw_status/status.h"
+
+namespace android::hardware::contexthub::common::implementation {
+
+using ::aidl::android::hardware::contexthub::EndpointId;
+using ::aidl::android::hardware::contexthub::EndpointInfo;
+using ::aidl::android::hardware::contexthub::HubInfo;
+using ::aidl::android::hardware::contexthub::IEndpointCallback;
+
+/**
+ * Stores host and embedded MessageHub objects and maintains global mappings.
+ */
+class MessageHubManager {
+ public:
+ /**
+ * Represents a host-side MessageHub. Clients of the IContextHub (V4+)
+ * interface each get a HostHub instance.
+ */
+ class HostHub {
+ public:
+ ~HostHub();
+
+ /**
+ * Sets the callback for sending endpoint events back to the HAL client
+ *
+ * @param callback The callback provided by the client
+ * @return pw::OkStatus() on success.
+ */
+ pw::Status setCallback(std::shared_ptr<IEndpointCallback> callback)
+ EXCLUDES(mManager.mLock);
+
+ /**
+ * Returns the callback registered in setCallback()
+ *
+ * @return The previously registered callback
+ */
+ std::shared_ptr<IEndpointCallback> getCallback() const
+ EXCLUDES(mManager.mLock);
+
+ /**
+ * Adds an endpoint to this message hub
+ *
+ * @param self Self-reference for mapping from hub id
+ * @param info Description of the endpoint
+ * @return pw::OkStatus() on success
+ */
+ pw::Status addEndpoint(std::weak_ptr<HostHub> self,
+ const EndpointInfo &info) EXCLUDES(mManager.mLock);
+
+ /**
+ * Removes an endpoint from this message hub
+ *
+ * @param info Id of endpoint to remove
+ * @return pw::OkStatus() on success
+ */
+ pw::Status removeEndpoint(const EndpointId &info) EXCLUDES(mManager.mLock);
+
+ /**
+ * Reserves a session id range to be used by this message hub
+ *
+ * @param size The size of this range, max 1024
+ * @return A pair of the smallest and largest id in the range on success
+ */
+ pw::Result<std::pair<uint16_t, uint16_t>> reserveSessionIdRange(
+ uint16_t size) EXCLUDES(mManager.mLock);
+
+ /**
+ * Opens a session between the given endpoints with given session id
+ *
+ * The session is pending until updated by the destination endpoint.
+ *
+ * @param self Self-reference to be stored in session state
+ * @param localId The id of an endpoint hosted by this hub
+ * @param remoteId The id of the remote endpoint
+ * @param sessionId The id to be used for this session. Must be in the range
+ * allocated to this hub
+ * @return On success, returns a possibly null reference to the HostHub
+ * which hosted an endpoint on a pruned session with the same id. If not
+ * null, the HostHub should be notified that the session has been closed.
+ */
+ pw::Result<std::shared_ptr<HostHub>> openSession(
+ std::weak_ptr<HostHub> self, const EndpointId &localId,
+ const EndpointId &remoteId, uint16_t sessionId)
+ EXCLUDES(mManager.mLock);
+
+ /**
+ * Acks a pending session.
+ *
+ * @param id Session id
+ * @return pw::OkStatus() on success, pw::Status::Unavailable() if the
+ * session is gone due to an endpoint going down.
+ */
+ pw::Status ackSession(uint16_t id) EXCLUDES(mManager.mLock);
+
+ /**
+ * Checks that a session is open.
+ *
+ * @param id Session id
+ * @return pw::OkStatus() on success, pw::Status::Unavailable() if the
+ * session is gone due to an endpoint going down.
+ */
+ pw::Status checkSessionOpen(uint16_t id) EXCLUDES(mManager.mLock);
+
+ /**
+ * Removes the given session and any local and global mappings
+ *
+ * @param id The session id
+ * @return pw::OkStatus() on success
+ */
+ pw::Status closeSession(uint16_t id) EXCLUDES(mManager.mLock);
+
+ /**
+ * Returns the registered id of this message hub.
+ *
+ * @return kId
+ */
+ int64_t id() const;
+
+ private:
+ friend class MessageHubManager;
+
+ // Cookie associated with each registered client callback.
+ struct DeathRecipientCookie {
+ MessageHubManager *manager;
+ pid_t pid;
+ };
+
+ static constexpr uint16_t kSessionIdMaxRange = 1024;
+
+ static constexpr int64_t kHubIdInvalid = 0;
+
+ HostHub(MessageHubManager &manager, pid_t pid)
+ : mManager(manager), kPid(pid) {}
+
+ // Unlinks this hub from the manager, destroying internal references.
+ // Returns the id so that it can be propagated to CHRE.
+ int64_t unlinkFromManager() EXCLUDES(mManager.mLock);
+
+ // Unlink the current callback from the manager's death recipient.
+ void unlinkCallbackIfNecessaryLocked() REQUIRES(mManager.mLock);
+
+ // Returns pw::OkStatus() if the hub is in a valid state.
+ pw::Status checkValidLocked() REQUIRES(mManager.mLock);
+
+ // Returns a shared_ptr to the given endpoint.
+ pw::Result<std::shared_ptr<EndpointInfo>> getEndpointLocked(
+ const EndpointId &id) REQUIRES(mManager.mLock);
+
+ // Returns pw::OkStatus() if the session id is in range for this hub.
+ bool sessionIdInRangeLocked(uint16_t id) REQUIRES(mManager.mLock);
+
+ MessageHubManager &mManager;
+ const pid_t kPid;
+
+ // Hub id, set when the first endpoint is registered.
+ int64_t kId GUARDED_BY(mManager.mLock) = kHubIdInvalid;
+
+ // Callback to HAL client.
+ std::shared_ptr<IEndpointCallback> mCallback GUARDED_BY(mManager.mLock);
+
+ // Cookie associated with mCallback.
+ DeathRecipientCookie *mCookie GUARDED_BY(mManager.mLock);
+
+ // Used to lookup a host endpoint. Owns the associated EndpointInfo.
+ std::unordered_map<int64_t, std::shared_ptr<EndpointInfo>> mIdToEndpoint
+ GUARDED_BY(mManager.mLock);
+
+ // Session id ranges allocated to this HostHub. The ranges are stored as a
+ // pair of the lowest and highest id in the range.
+ std::vector<std::pair<uint16_t, uint16_t>> mSessionIdRanges
+ GUARDED_BY(mManager.mLock);
+
+ // Set in unlinkFromManager().
+ bool mUnlinked GUARDED_BY(mManager.mLock) = false;
+ };
+
+ // Callback registered to pass up the id of a host hub which disconnected.
+ using HostHubDownCb = std::function<void(int64_t hubId)>;
+
+ // The base session id for sessions initiated from host endpoints.
+ static constexpr uint16_t kHostSessionIdBase = 0x8000;
+
+ explicit MessageHubManager(HostHubDownCb cb);
+ ~MessageHubManager() = default;
+
+ /**
+ * Retrieves the HostHub instance for the calling process
+ *
+ * This API should be used for any HostHub lookup coming from the
+ * IContextHub interface. The first call to this API by any client process
+ * will trigger the creation of a HostHub for that client.
+ *
+ * @param pid The caller's system process id
+ * @return shared_ptr to the HostHub instance
+ */
+ std::shared_ptr<HostHub> getHostHubByPid(pid_t pid) EXCLUDES(mLock);
+
+ /**
+ * Retrieves the HostHub instance for the given EndpointId
+ *
+ * @param id The endpoint id hosted by the returned hub
+ * @return shared_ptr to the HostHub instance
+ */
+ std::shared_ptr<HostHub> getHostHubByEndpointId(const EndpointId &id)
+ EXCLUDES(mLock);
+
+ /**
+ * Checks that a given session is open and returns its HostHub.
+ *
+ * @param id Session id
+ * @return A strong reference to the HostHub. pw::Status::Unavailable()
+ * indicates that the session has been pruned.
+ */
+ pw::Result<std::shared_ptr<HostHub>> checkSessionOpenAndGetHostHub(
+ uint16_t id) EXCLUDES(mLock);
+
+ /**
+ * Acks a session open request.
+ *
+ * This is called both when the destination endpoint approves and also when
+ * MessageRouter gives a final ack on a session initiated from an embedded
+ * endpoint. See the documentation on the Session class.
+ *
+ * @param id Session id
+ * @return A strong reference to the HostHub. pw::Status::Unavailable()
+ * indicates that the session has been pruned.
+ */
+ pw::Result<std::shared_ptr<HostHub>> ackSessionAndGetHostHub(uint16_t id)
+ EXCLUDES(mLock);
+
+ /**
+ * Apply the given function to each host hub.
+ *
+ * @param fn The function to apply.
+ */
+ void forEachHostHub(std::function<void(HostHub &hub)> fn);
+
+ /**
+ * Wipes and initializes the cache of embedded hubs and endpoints
+ *
+ * This should only be called once during startup as it invalidates session
+ * state (i.e. existing sessions will be pruned).
+ *
+ * @param hubs The list of message hubs
+ * @param endpoints The list of endpoints
+ */
+ void initEmbeddedHubsAndEndpoints(const std::vector<HubInfo> &hubs,
+ const std::vector<EndpointInfo> &endpoints)
+ EXCLUDES(mLock);
+
+ /**
+ * Adds the given hub to the cache
+ *
+ * Ignored if the hub already exists
+ *
+ * @param hub The hub to add
+ */
+ void addEmbeddedHub(const HubInfo &hub) EXCLUDES(mLock);
+
+ /**
+ * Removes the hub with given id from the cache
+ *
+ * @param id The id of the hub to remove
+ * @return The ids of all endpoints on the embedded hub
+ */
+ std::vector<EndpointId> removeEmbeddedHub(int64_t id) EXCLUDES(mLock);
+
+ /**
+ * Returns the cached list of embedded message hubs
+ *
+ * @return HubInfo for every embedded message hub
+ */
+ std::vector<HubInfo> getEmbeddedHubs() const EXCLUDES(mLock);
+
+ /**
+ * Adds an embedded endpoint to the cache
+ *
+ * Ignored if the endpoint already exists
+ *
+ * @param endpoint The endpoint to add
+ */
+ void addEmbeddedEndpoint(const EndpointInfo &endpoint);
+
+ /**
+ * Removes an embedded endpoint from the cache
+ *
+ * @param id The id of the endpoint to remove
+ */
+ void removeEmbeddedEndpoint(const EndpointId &endpoint);
+
+ /**
+ * Returns a list of embedded endpoints
+ *
+ * @return EndpointInfo for every embedded endpoint
+ */
+ std::vector<EndpointInfo> getEmbeddedEndpoints() const EXCLUDES(mLock);
+
+ private:
+ // Callback invoked when a client goes down.
+ using UnlinkToDeathFn = std::function<bool(
+ const std::shared_ptr<IEndpointCallback> &callback, void *cookie)>;
+
+ // Represents an embedded MessageHub. Stores the hub details as well as a map
+ // of all endpoints hosted by the hub.
+ struct EmbeddedHub {
+ std::unordered_map<int64_t, std::shared_ptr<EndpointInfo>> idToEndpoint;
+ HubInfo info;
+ };
+
+ // Represents a session between a host and embedded endpoint. Only stores weak
+ // references to the endpoints and HostHub owning the host endpoint. Must be
+ // converted to a SessionStrongRef to temporarily access state. The weak
+ // references expire when the associated entity is unregistered. A
+ // SessionStrongRef cannot be created if any reference has expired.
+ //
+ // A Session is created on an openSession() request (triggered either by a
+ // local or remote endpoint) with mPendingDestination unset via a call to
+ // ackSession*() from the destination endpoint. For Sessions started by
+ // embedded endpoints, an additional ackSession*() must be received from the
+ // CHRE MessageRouter after passing it the ack from the destination host
+ // endpoint. This unsets mPendingMessageRouter. A session is only open for
+ // messages once both mPendingDestination and mPendingMessageRouter are unset.
+ struct SessionStrongRef;
+ class Session {
+ public:
+ Session(std::weak_ptr<HostHub> hub, std::weak_ptr<EndpointInfo> local,
+ std::weak_ptr<EndpointInfo> remote, bool hostInitiated)
+ : mHub(hub),
+ mLocal(local),
+ mRemote(remote),
+ mPendingMessageRouter(!hostInitiated) {}
+
+ private:
+ friend struct SessionStrongRef;
+
+ std::weak_ptr<HostHub> mHub;
+ std::weak_ptr<EndpointInfo> mLocal;
+ std::weak_ptr<EndpointInfo> mRemote;
+ bool mPendingDestination = true;
+ bool mPendingMessageRouter;
+ };
+
+ // A strong reference to a Session's underlying endpoints and HostHub as well
+ // as Session metadata. A SessionStrongRef should be created and destroyed
+ // within a single critical section.
+ struct SessionStrongRef {
+ std::shared_ptr<HostHub> hub;
+ std::shared_ptr<EndpointInfo> local;
+ std::shared_ptr<EndpointInfo> remote;
+ bool &pendingDestination;
+ bool &pendingMessageRouter;
+
+ SessionStrongRef(Session &session)
+ : hub(session.mHub.lock()),
+ local(session.mLocal.lock()),
+ remote(session.mRemote.lock()),
+ pendingDestination(session.mPendingDestination),
+ pendingMessageRouter(session.mPendingMessageRouter) {}
+ operator bool() const {
+ return hub && local && remote;
+ }
+ };
+
+ // The hub id reserved for the ContextHub service.
+ static constexpr int64_t kContextHubServiceHubId = 0x416e64726f696400;
+
+ // The Linux uid of the system_server.
+ static constexpr uid_t kSystemServerUid = 1000;
+
+ // Invoked on client death. Cleans up references to the client.
+ static void onClientDeath(void *cookie);
+
+ // Retrieves a strong reference to the session with given id.
+ pw::Result<SessionStrongRef> checkSessionLocked(uint16_t id) REQUIRES(mLock);
+
+ // Adds an embedded endpoint to the cache.
+ void addEmbeddedEndpointLocked(const EndpointInfo &endpoint) REQUIRES(mLock);
+
+ // Returns true if the embedded endpoint with given id is in the cache.
+ pw::Result<std::shared_ptr<EndpointInfo>> getEmbeddedEndpointLocked(
+ const EndpointId &id) REQUIRES(mLock);
+
+ // Callback to pass up the id of a host hub for a client that disconnected.
+ HostHubDownCb mHostHubDownCb;
+
+ // Death recipient handling clients' disconnections.
+ ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
+
+ // Guards hub, endpoint, and session state.
+ mutable std::mutex mLock;
+
+ // Map of EmbeddedHubs.
+ std::unordered_map<int64_t, EmbeddedHub> mIdToEmbeddedHub GUARDED_BY(mLock);
+
+ // Used to look up the HostHub associated with the client on IContextHub
+ // calls.
+ std::unordered_map<pid_t, std::shared_ptr<HostHub>> mPidToHostHub
+ GUARDED_BY(mLock);
+
+ // Used when an embedded endpoint wants to start a session with an endpoint
+ // hosted by a specific HostHub.
+ std::unordered_map<int64_t, std::weak_ptr<HostHub>> mIdToHostHub
+ GUARDED_BY(mLock);
+
+ // Used to lookup the host endpoint to receive a message on an endpoint
+ // session.
+ std::unordered_map<uint16_t, Session> mIdToSession GUARDED_BY(mLock);
+
+ // Next session id from which to allocate ranges.
+ uint16_t mNextSessionId GUARDED_BY(mLock) = kHostSessionIdBase;
+};
+
+} // namespace android::hardware::contexthub::common::implementation
diff --git a/host/hal_generic/common/multi_client_context_hub_base.cc b/host/hal_generic/common/multi_client_context_hub_base.cc
index 8eb92eb..356de2a 100644
--- a/host/hal_generic/common/multi_client_context_hub_base.cc
+++ b/host/hal_generic/common/multi_client_context_hub_base.cc
@@ -39,7 +39,6 @@
using ::android::chre::Atoms::ChreHalNanoappLoadFailed;
using ::android::chre::flags::abort_if_no_context_hub_found;
using ::android::chre::flags::bug_fix_hal_reliable_message_record;
-using ::android::chre::flags::reliable_message_implementation;
using ::ndk::ScopedAStatus;
namespace fbs = ::chre::fbs;
@@ -172,6 +171,12 @@
ScopedAStatus MultiClientContextHubBase::getContextHubs(
std::vector<ContextHubInfo> *contextHubInfos) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ // Return ok() here to not crash system server
+ return ScopedAStatus::ok();
+ }
+
std::unique_lock<std::mutex> lock(mHubInfoMutex);
if (mContextHubInfo == nullptr) {
fbs::HubInfoResponseT response;
@@ -200,10 +205,15 @@
ScopedAStatus MultiClientContextHubBase::loadNanoapp(
int32_t contextHubId, const NanoappBinary &appBinary,
int32_t transactionId) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
- LOGD("Loading nanoapp 0x%" PRIx64, appBinary.nanoappId);
+ LOGD("Loading nanoapp 0x%" PRIx64 ", transaction id=%" PRIi32,
+ appBinary.nanoappId, transactionId);
uint32_t targetApiVersion = (appBinary.targetChreApiMajorVersion << 24) |
(appBinary.targetChreApiMinorVersion << 16);
auto nanoappBuffer =
@@ -254,6 +264,10 @@
ScopedAStatus MultiClientContextHubBase::unloadNanoapp(int32_t contextHubId,
int64_t appId,
int32_t transactionId) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
@@ -296,6 +310,10 @@
ScopedAStatus MultiClientContextHubBase::onSettingChanged(Setting setting,
bool enabled) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
mSettingEnabled[setting] = enabled;
fbs::Setting fbsSetting;
bool isWifiOrBtSetting =
@@ -346,6 +364,10 @@
}
ScopedAStatus MultiClientContextHubBase::queryNanoapps(int32_t contextHubId) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
@@ -380,6 +402,8 @@
ScopedAStatus MultiClientContextHubBase::registerCallback(
int32_t contextHubId,
const std::shared_ptr<IContextHubCallback> &callback) {
+ // Even CHRE is not ready we should open this API to clients because it allows
+ // us to have a channel to report events back to them.
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
@@ -406,6 +430,10 @@
ScopedAStatus MultiClientContextHubBase::sendMessageToHub(
int32_t contextHubId, const ContextHubMessage &message) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
@@ -416,7 +444,7 @@
return fromResult(false);
}
- if (reliable_message_implementation() && message.isReliable) {
+ if (message.isReliable) {
if (bug_fix_hal_reliable_message_record()) {
std::lock_guard<std::mutex> lock(mReliableMessageMutex);
auto iter = std::find_if(
@@ -439,19 +467,12 @@
}
flatbuffers::FlatBufferBuilder builder(1024);
- if (reliable_message_implementation()) {
- HostProtocolHost::encodeNanoappMessage(
- builder, message.nanoappId, message.messageType, hostEndpointId,
- message.messageBody.data(), message.messageBody.size(),
- /* permissions= */ 0,
- /* messagePermissions= */ 0,
- /* wokeHost= */ false, message.isReliable,
- message.messageSequenceNumber);
- } else {
- HostProtocolHost::encodeNanoappMessage(
- builder, message.nanoappId, message.messageType, hostEndpointId,
- message.messageBody.data(), message.messageBody.size());
- }
+ HostProtocolHost::encodeNanoappMessage(
+ builder, message.nanoappId, message.messageType, hostEndpointId,
+ message.messageBody.data(), message.messageBody.size(),
+ /* permissions= */ 0,
+ /* messagePermissions= */ 0,
+ /* wokeHost= */ false, message.isReliable, message.messageSequenceNumber);
bool success = mConnection->sendMessage(builder);
mEventLogger.logMessageToNanoapp(message, success);
@@ -460,6 +481,10 @@
ScopedAStatus MultiClientContextHubBase::onHostEndpointConnected(
const HostEndpointInfo &info) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
uint8_t type;
switch (info.type) {
case HostEndpointInfo::Type::APP:
@@ -491,6 +516,10 @@
ScopedAStatus MultiClientContextHubBase::onHostEndpointDisconnected(
char16_t in_hostEndpointId) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
HostEndpointId hostEndpointId = in_hostEndpointId;
pid_t pid = AIBinder_getCallingPid();
bool isSuccessful = false;
@@ -509,11 +538,19 @@
ScopedAStatus MultiClientContextHubBase::onNanSessionStateChanged(
const NanSessionStateUpdate & /*in_update*/) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
// TODO(271471342): Add support for NAN session management.
return ndk::ScopedAStatus::ok();
}
ScopedAStatus MultiClientContextHubBase::setTestMode(bool enable) {
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
+ }
if (enable) {
return fromResult(enableTestMode());
}
@@ -523,10 +560,10 @@
ScopedAStatus MultiClientContextHubBase::sendMessageDeliveryStatusToHub(
int32_t contextHubId, const MessageDeliveryStatus &messageDeliveryStatus) {
- if (!reliable_message_implementation()) {
- return ScopedAStatus::ok();
+ if (!mIsChreReady) {
+ LOGE("%s() can't be processed as CHRE is not ready", __func__);
+ return fromServiceError(HalError::CHRE_NOT_READY);
}
-
if (!isValidContextHubId(contextHubId)) {
return ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
@@ -543,6 +580,77 @@
return fromResult(success);
}
+ScopedAStatus MultiClientContextHubBase::getHubs(std::vector<HubInfo> *hubs) {
+ if (mV4Impl) return mV4Impl->getHubs(hubs);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::getEndpoints(
+ std::vector<EndpointInfo> *endpoints) {
+ if (mV4Impl) return mV4Impl->getEndpoints(endpoints);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::registerEndpoint(
+ const EndpointInfo &endpoint) {
+ if (mV4Impl) return mV4Impl->registerEndpoint(endpoint);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::unregisterEndpoint(
+ const EndpointInfo &endpoint) {
+ if (mV4Impl) return mV4Impl->unregisterEndpoint(endpoint);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback) {
+ if (mV4Impl) return mV4Impl->registerEndpointCallback(callback);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::requestSessionIdRange(
+ int32_t size, std::vector<int32_t> *ids) {
+ if (mV4Impl) return mV4Impl->requestSessionIdRange(size, ids);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> &serviceDescriptor) {
+ if (mV4Impl) {
+ return mV4Impl->openEndpointSession(sessionId, destination, initiator,
+ serviceDescriptor);
+ }
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::sendMessageToEndpoint(
+ int32_t sessionId, const Message &msg) {
+ if (mV4Impl) return mV4Impl->sendMessageToEndpoint(sessionId, msg);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus &msgStatus) {
+ if (mV4Impl)
+ return mV4Impl->sendMessageDeliveryStatusToEndpoint(sessionId, msgStatus);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::closeEndpointSession(int32_t sessionId,
+ Reason reason) {
+ if (mV4Impl) return mV4Impl->closeEndpointSession(sessionId, reason);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
+ScopedAStatus MultiClientContextHubBase::endpointSessionOpenComplete(
+ int32_t sessionId) {
+ if (mV4Impl) return mV4Impl->endpointSessionOpenComplete(sessionId);
+ return ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
+
bool MultiClientContextHubBase::enableTestMode() {
std::unique_lock<std::mutex> lock(mTestModeMutex);
if (mIsTestModeEnabled) {
@@ -688,8 +796,12 @@
break;
}
default:
- LOGW("Got unexpected message type %" PRIu8,
- static_cast<uint8_t>(message.type));
+ if (mV4Impl) {
+ mV4Impl->handleMessageFromChre(message);
+ } else {
+ LOGW("Got unexpected message type %" PRIu8,
+ static_cast<uint8_t>(message.type));
+ }
}
}
@@ -711,7 +823,7 @@
mContextHubInfo->supportedPermissions = kSupportedPermissions;
mContextHubInfo->supportsReliableMessages =
- reliable_message_implementation() && response.supports_reliable_messages;
+ response.supports_reliable_messages;
mHubInfoCondition.notify_all();
}
@@ -889,14 +1001,8 @@
outMessage.messageType = message.message_type;
outMessage.messageBody = message.message;
outMessage.permissions = chreToAndroidPermissions(message.permissions);
-
- if (reliable_message_implementation()) {
- outMessage.isReliable = message.is_reliable;
- outMessage.messageSequenceNumber = message.message_sequence_number;
- } else {
- outMessage.isReliable = false;
- outMessage.messageSequenceNumber = 0;
- }
+ outMessage.isReliable = message.is_reliable;
+ outMessage.messageSequenceNumber = message.message_sequence_number;
std::string messageSeq = "reliable message seq=" +
std::to_string(outMessage.messageSequenceNumber);
@@ -927,10 +1033,6 @@
void MultiClientContextHubBase::onMessageDeliveryStatus(
const ::chre::fbs::MessageDeliveryStatusT &status) {
- if (!reliable_message_implementation()) {
- return;
- }
-
HostEndpointId hostEndpointId;
if (bug_fix_hal_reliable_message_record()) {
{
@@ -1007,6 +1109,15 @@
mIsWifiAvailable.reset();
mEventLogger.logContextHubRestart();
mHalClientManager->handleChreRestart();
+
+ // Unblock APIs BEFORE informing the clients that CHRE has restarted so that
+ // any API call triggered by handleContextHubAsyncEvent() can come through.
+ mIsChreReady = true;
+ std::vector<std::shared_ptr<IContextHubCallback>> callbacks =
+ mHalClientManager->getCallbacks();
+ for (auto callback : callbacks) {
+ callback->handleContextHubAsyncEvent(AsyncEventType::RESTARTED);
+ }
}
binder_status_t MultiClientContextHubBase::dump(int fd,
diff --git a/host/hal_generic/common/multi_client_context_hub_base.h b/host/hal_generic/common/multi_client_context_hub_base.h
index c596089..ea7b6f3 100644
--- a/host/hal_generic/common/multi_client_context_hub_base.h
+++ b/host/hal_generic/common/multi_client_context_hub_base.h
@@ -26,6 +26,7 @@
#include "chre_host/napp_header.h"
#include "chre_host/preloaded_nanoapp_loader.h"
#include "chre_host/time_syncer.h"
+#include "context_hub_v4_impl.h"
#include "debug_dump_helper.h"
#include "event_logger.h"
#include "hal_client_id.h"
@@ -33,9 +34,11 @@
#include <chrono>
#include <deque>
+#include <memory>
#include <mutex>
#include <optional>
#include <unordered_map>
+#include <vector>
namespace android::hardware::contexthub::common::implementation {
@@ -89,11 +92,32 @@
ScopedAStatus sendMessageDeliveryStatusToHub(
int32_t contextHubId,
const MessageDeliveryStatus &messageDeliveryStatus) override;
+ ScopedAStatus getHubs(std::vector<HubInfo> *hubs) override;
+ ScopedAStatus getEndpoints(std::vector<EndpointInfo> *endpoints) override;
+ ScopedAStatus registerEndpoint(const EndpointInfo &endpoint) override;
+ ScopedAStatus unregisterEndpoint(const EndpointInfo &endpoint) override;
+ ScopedAStatus registerEndpointCallback(
+ const std::shared_ptr<IEndpointCallback> &callback) override;
+ ScopedAStatus requestSessionIdRange(int32_t size,
+ std::vector<int32_t> *ids) override;
+ ScopedAStatus openEndpointSession(
+ int32_t sessionId, const EndpointId &destination,
+ const EndpointId &initiator,
+ const std::optional<std::string> &serviceDescriptor) override;
+ ScopedAStatus sendMessageToEndpoint(int32_t sessionId,
+ const Message &msg) override;
+ ScopedAStatus sendMessageDeliveryStatusToEndpoint(
+ int32_t sessionId, const MessageDeliveryStatus &msgStatus) override;
+ ScopedAStatus closeEndpointSession(int32_t sessionId, Reason reason) override;
+ ScopedAStatus endpointSessionOpenComplete(int32_t sessionId) override;
// Functions implementing ChreConnectionCallback.
void handleMessageFromChre(const unsigned char *messageBuffer,
size_t messageLen) override;
void onChreRestarted() override;
+ void onChreDisconnected() override {
+ mIsChreReady = false;
+ }
// Functions for dumping debug information.
binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
@@ -197,6 +221,10 @@
// one instance of a HalClientManager.
std::unique_ptr<HalClientManager> mHalClientManager{};
+ // Implementation of the V4+ API. Should be instantiated by the target HAL
+ // implementation.
+ std::optional<ContextHubV4Impl> mV4Impl{};
+
std::unique_ptr<PreloadedNanoappLoader> mPreloadedNanoappLoader{};
std::unique_ptr<ContextHubInfo> mContextHubInfo;
@@ -242,6 +270,12 @@
std::mutex mReliableMessageMutex;
std::deque<ReliableMessageRecord> mReliableMessageQueue;
+ // A thread safe flag indicating if CHRE is ready for operations.
+ // Outside of the constructor, this boolean flag should only be written by
+ // onChreDisconnected and onChreRestarted, the order of which should be
+ // guaranteed by the CHRE's disconnection handler.
+ std::atomic_bool mIsChreReady = true;
+
// TODO(b/333567700): Remove when cleaning up the bug_fix_hal_reliable_message_record flag
std::unordered_map<int32_t, HostEndpointId> mReliableMessageMap;
};
diff --git a/host/test/hal_generic/common/hal_client_manager_test.cc b/host/test/hal_generic/common/hal_client_manager_test.cc
index e40e249..7a57a2c 100644
--- a/host/test/hal_generic/common/hal_client_manager_test.cc
+++ b/host/test/hal_generic/common/hal_client_manager_test.cc
@@ -535,7 +535,7 @@
EXPECT_THAT(client.endpointIds, IsEmpty());
}
-TEST_F(HalClientManagerTest, handleChreRestartForConnectedClientsOnly) {
+TEST_F(HalClientManagerTest, handleChreRestart) {
auto halClientManager = std::make_unique<HalClientManagerForTest>(
mockDeadClientUnlinker, kClientIdMappingFilePath);
std::shared_ptr<ContextHubCallbackForTest> vendorCallback =
@@ -550,17 +550,35 @@
EXPECT_TRUE(halClientManager->registerCallback(
kVendorPid, vendorCallback, /* deathRecipientCookie= */ nullptr));
- // Only connected clients' handleContextHubAsyncEvent should be called.
+ // Calls to clients' handleContextHubAsyncEvent should be postponed to HAL.
EXPECT_CALL(*systemCallback,
- handleContextHubAsyncEvent(AsyncEventType::RESTARTED));
+ handleContextHubAsyncEvent(AsyncEventType::RESTARTED))
+ .Times(0);
EXPECT_CALL(*vendorCallback,
handleContextHubAsyncEvent(AsyncEventType::RESTARTED))
.Times(0);
- // Disconnect the vendor client and handle CHRE restart for the system server
- halClientManager->handleClientDeath(kVendorPid);
halClientManager->handleChreRestart();
}
+TEST_F(HalClientManagerTest, getAllConnectedCallbacks) {
+ auto halClientManager = std::make_unique<HalClientManagerForTest>(
+ mockDeadClientUnlinker, kClientIdMappingFilePath);
+ std::shared_ptr<ContextHubCallbackForTest> vendorCallback =
+ ContextHubCallbackForTest::make<ContextHubCallbackForTest>(kVendorUuid);
+ std::shared_ptr<ContextHubCallbackForTest> systemCallback =
+ ContextHubCallbackForTest::make<ContextHubCallbackForTest>(
+ kSystemServerUuid);
+ // Register the system callback
+ EXPECT_TRUE(halClientManager->registerCallback(
+ kSystemServerPid, systemCallback, /* deathRecipientCookie= */ nullptr));
+ // Register the vendor callback
+ EXPECT_TRUE(halClientManager->registerCallback(
+ kVendorPid, vendorCallback, /* deathRecipientCookie= */ nullptr));
+
+ EXPECT_THAT(halClientManager->getCallbacks(),
+ UnorderedElementsAre(vendorCallback, systemCallback));
+}
+
} // namespace
} // namespace android::hardware::contexthub::common::implementation
diff --git a/host/tinysys/hal/Android.bp b/host/tinysys/hal/Android.bp
index dc7e51d..ba1e970 100644
--- a/host/tinysys/hal/Android.bp
+++ b/host/tinysys/hal/Android.bp
@@ -28,7 +28,10 @@
cc_binary {
name: "android.hardware.contexthub-service.tinysys",
cpp_std: "c++20",
- defaults: ["hidl_defaults"],
+ defaults: [
+ "contexthub_hal_defaults",
+ "hidl_defaults",
+ ],
vendor: true,
relative_install_path: "hw",
srcs: [
@@ -38,47 +41,13 @@
"tinysys_chre_connection.cc",
"tinysys_context_hub.cc",
],
- include_dirs: [
- "system/chre/host/common/include/",
- "system/chre/host/hal_generic/aidl/",
- "system/chre/host/hal_generic/common/",
- "system/chre/platform/shared/include/",
- "system/chre/util/include/",
- ],
- cflags: [
- "-DCHRE_HOST_DEFAULT_FRAGMENT_SIZE=2048",
- "-DCHRE_IS_HOST_BUILD",
- "-DCHRE_MESSAGE_TO_HOST_MAX_SIZE=4000",
- "-DCHRE_ST_LPMA_HANDLER_AIDL",
- "-Wall",
- "-Werror",
- ],
+ cflags: ["-DCHRE_ST_LPMA_HANDLER_AIDL"],
shared_libs: [
- "android.frameworks.stats-V2-ndk",
- "android.hardware.contexthub-V3-ndk",
"android.hardware.soundtrigger3-V1-ndk",
"android.media.soundtrigger.types-V1-ndk",
- "chre_atoms_log",
- "chremetrics-cpp",
- "libaconfig_storage_read_api_cc",
- "libbase",
- "libbinder_ndk",
- "libcutils",
- "libjsoncpp",
- "liblog",
"libpower",
- "libprotobuf-cpp-lite",
- "libutils",
- "server_configurable_flags",
- ],
- header_libs: [
- "chre_api",
],
static_libs: [
- "chre_client",
- "chre_flags_c_lib",
- "chre_metrics_reporter",
- "event_logger",
"pw_detokenizer",
"pw_polyfill",
"pw_span",
diff --git a/host/tinysys/hal/android.hardware.contexthub-service.tinysys.xml b/host/tinysys/hal/android.hardware.contexthub-service.tinysys.xml
index db2e2d7..3d9d4af 100644
--- a/host/tinysys/hal/android.hardware.contexthub-service.tinysys.xml
+++ b/host/tinysys/hal/android.hardware.contexthub-service.tinysys.xml
@@ -1,7 +1,7 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.contexthub</name>
- <version>3</version>
+ <version>4</version>
<fqname>IContextHub/default</fqname>
</hal>
</manifest>
diff --git a/host/tinysys/hal/tinysys_chre_connection.cc b/host/tinysys/hal/tinysys_chre_connection.cc
index ddd8402..777596f 100644
--- a/host/tinysys/hal/tinysys_chre_connection.cc
+++ b/host/tinysys/hal/tinysys_chre_connection.cc
@@ -70,8 +70,8 @@
bool TinysysChreConnection::init() {
// Make sure the payload size is large enough for nanoapp binary fragment
- static_assert(kMaxPayloadBytes > CHRE_HOST_DEFAULT_FRAGMENT_SIZE &&
- kMaxPayloadBytes - CHRE_HOST_DEFAULT_FRAGMENT_SIZE >
+ static_assert(kMaxSendingPayloadBytes > CHRE_HOST_DEFAULT_FRAGMENT_SIZE &&
+ kMaxSendingPayloadBytes - CHRE_HOST_DEFAULT_FRAGMENT_SIZE >
kMaxPayloadOverheadBytes);
mChreFileDescriptor =
TEMP_FAILURE_RETRY(open(kChreFileDescriptorPath, O_RDWR));
@@ -93,8 +93,8 @@
auto chreFd = chreConnection->getChreFileDescriptor();
while (true) {
{
- ssize_t payloadSize = TEMP_FAILURE_RETRY(
- read(chreFd, chreConnection->mPayload.get(), kMaxPayloadBytes));
+ ssize_t payloadSize = TEMP_FAILURE_RETRY(read(
+ chreFd, chreConnection->mPayload.get(), kMaxReceivingPayloadBytes));
if (payloadSize == 0) {
// Payload size 0 is a fake signal from kernel which is normal if the
// device is in sleep.
@@ -161,7 +161,7 @@
}
bool TinysysChreConnection::sendMessage(void *data, size_t length) {
- if (length <= 0 || length > kMaxPayloadBytes) {
+ if (length <= 0 || length > kMaxSendingPayloadBytes) {
LOGE("length %zu is not within the accepted range.", length);
return false;
}
diff --git a/host/tinysys/hal/tinysys_chre_connection.h b/host/tinysys/hal/tinysys_chre_connection.h
index d30ba8f..5c771b4 100644
--- a/host/tinysys/hal/tinysys_chre_connection.h
+++ b/host/tinysys/hal/tinysys_chre_connection.h
@@ -44,7 +44,7 @@
public:
TinysysChreConnection(ChreConnectionCallback *callback)
: mCallback(callback), mLpmaHandler(/* allowed= */ true) {
- mPayload = std::make_unique<uint8_t[]>(kMaxPayloadBytes);
+ mPayload = std::make_unique<uint8_t[]>(kMaxReceivingPayloadBytes);
};
~TinysysChreConnection() override {
@@ -104,11 +104,10 @@
static constexpr char kWakeLock[] = "tinysys_chre_hal_wakelock";
// Max payload size that can be sent to CHRE
- // TODO(b/277235389): Adjust max payload size (AP -> SCP and SCP -> AP)
- // as appropriate. This is a temp/quick fix for b/272311907 and b/270758946
- // setting max payload allowed to CHRE_MESSAGE_TO_HOST_MAX_SIZE + 128 byte
- // to account for transport overhead.
- static constexpr uint32_t kMaxPayloadBytes = 4224; // 4096 + 128
+ static constexpr uint32_t kMaxSendingPayloadBytes = 0x8000; // 32K
+
+ // Max payload size that can be received from CHRE
+ static constexpr uint32_t kMaxReceivingPayloadBytes = 0x8000; // 32K
// Max overhead of the nanoapp binary payload caused by the fbs encapsulation
static constexpr uint32_t kMaxPayloadOverheadBytes = 1024;
@@ -126,10 +125,10 @@
// security check for proper use of the device node.
uint32_t magic = 0x67728269;
uint32_t payloadSize = 0;
- uint8_t payload[kMaxPayloadBytes];
+ uint8_t payload[kMaxSendingPayloadBytes];
ChreConnectionMessage(void *data, size_t length) {
- assert(length <= kMaxPayloadBytes);
+ assert(length <= kMaxSendingPayloadBytes);
memcpy(payload, data, length);
payloadSize = static_cast<uint32_t>(length);
}
diff --git a/java/test/audio_diagnostics/src/com/google/android/chre/test/audio_diagnostics/ContextHubAudioDiagnosticsTestExecutor.java b/java/test/audio_diagnostics/src/com/google/android/chre/test/audio_diagnostics/ContextHubAudioDiagnosticsTestExecutor.java
index e67f038..b7defb0 100644
--- a/java/test/audio_diagnostics/src/com/google/android/chre/test/audio_diagnostics/ContextHubAudioDiagnosticsTestExecutor.java
+++ b/java/test/audio_diagnostics/src/com/google/android/chre/test/audio_diagnostics/ContextHubAudioDiagnosticsTestExecutor.java
@@ -149,8 +149,8 @@
"audio_dc_offset_test_data.bin", mContext);
Log.i(TAG, "DC Offset: " + runningSampleAvg);
- Assert.assertTrue("DC offset " + runningSampleAvg + " >= threshold " + DC_OFFSET_LIMIT,
- runningSampleAvg < DC_OFFSET_LIMIT);
+ Assert.assertTrue("DC offset " + runningSampleAvg + " > threshold " + DC_OFFSET_LIMIT,
+ runningSampleAvg <= DC_OFFSET_LIMIT);
}
/**
diff --git a/java/test/chqts/src/com/google/android/chre/test/chqts/ContextHubPendingIntentTestExecutor.java b/java/test/chqts/src/com/google/android/chre/test/chqts/ContextHubPendingIntentTestExecutor.java
index 272de45..98320d7 100644
--- a/java/test/chqts/src/com/google/android/chre/test/chqts/ContextHubPendingIntentTestExecutor.java
+++ b/java/test/chqts/src/com/google/android/chre/test/chqts/ContextHubPendingIntentTestExecutor.java
@@ -84,7 +84,7 @@
}
public void init() throws InterruptedException, TimeoutException {
- mTestHelper.initAndUnloadAllNanoApps();
+ mTestHelper.init();
}
/**
diff --git a/java/test/cross_validation/src/com/google/android/chre/test/crossvalidator/ChreCrossValidatorBase.java b/java/test/cross_validation/src/com/google/android/chre/test/crossvalidator/ChreCrossValidatorBase.java
index c564127..0727580 100644
--- a/java/test/cross_validation/src/com/google/android/chre/test/crossvalidator/ChreCrossValidatorBase.java
+++ b/java/test/cross_validation/src/com/google/android/chre/test/crossvalidator/ChreCrossValidatorBase.java
@@ -23,14 +23,9 @@
import android.hardware.location.ContextHubTransaction;
import android.hardware.location.NanoAppBinary;
import android.hardware.location.NanoAppMessage;
-import android.hardware.location.NanoAppState;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
-import android.util.Log;
import com.google.android.utils.chre.ChreTestUtil;
-import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
@@ -99,9 +94,6 @@
/**
* Validate the data from AP and CHRE according to the parameters passed to this cross
* validator. Should be called in @Test methods of tests.
- *
- * @param samplingDurationInMs The amount of time in milliseconds to collect samples from AP and
- * CHRE.
*/
public abstract void validate() throws AssertionError, InterruptedException;
@@ -120,28 +112,6 @@
}
/**
- * Unloads all nanoapps from device. Call before validating data to ensure no inconsistencies
- * with data received.
- */
- private void unloadAllNanoApps() {
- // We only need to unload all nanoapps when the device has version < U, so the
- // tests remain the same on those devices. On newer devices, test mode will
- // handle this.
- if (VERSION.SDK_INT >= VERSION_CODES.UPSIDE_DOWN_CAKE) {
- return;
- }
-
- List<NanoAppState> nanoAppStateList =
- ChreTestUtil.queryNanoAppsAssertSuccess(mContextHubManager, mContextHubInfo);
-
- for (NanoAppState state : nanoAppStateList) {
- ChreTestUtil.unloadNanoAppAssertSuccess(
- mContextHubManager, mContextHubInfo, state.getNanoAppId());
- Log.d(TAG, String.format("Unloaded napp: 0x%X", state.getNanoAppId()));
- }
- }
-
- /**
* Close the context hub client connection.
*/
private void closeContextHubConnection() {
@@ -163,28 +133,20 @@
* @return the name of the context hub result.
*/
protected static String contextHubTransactionResultToString(int result) {
- switch (result) {
- case ContextHubTransaction.RESULT_SUCCESS:
- return "RESULT_SUCCESS";
- case ContextHubTransaction.RESULT_FAILED_UNKNOWN:
- return "RESULT_FAILED_UNKNOWN";
- case ContextHubTransaction.RESULT_FAILED_BAD_PARAMS:
- return "RESULT_FAILED_BAD_PARAMS";
- case ContextHubTransaction.RESULT_FAILED_UNINITIALIZED:
- return "RESULT_FAILED_UNINITIALIZED";
- case ContextHubTransaction.RESULT_FAILED_BUSY:
- return "RESULT_FAILED_BUSY";
- case ContextHubTransaction.RESULT_FAILED_AT_HUB:
- return "RESULT_FAILED_AT_HUB";
- case ContextHubTransaction.RESULT_FAILED_TIMEOUT:
- return "RESULT_FAILED_TIMEOUT";
- case ContextHubTransaction.RESULT_FAILED_SERVICE_INTERNAL_FAILURE:
- return "RESULT_FAILED_SERVICE_INTERNAL_FAILURE";
- case ContextHubTransaction.RESULT_FAILED_HAL_UNAVAILABLE:
- return "RESULT_FAILED_HAL_UNAVAILABLE";
- default:
- return "UNKNOWN_RESULT";
- }
+ return switch (result) {
+ case ContextHubTransaction.RESULT_SUCCESS -> "RESULT_SUCCESS";
+ case ContextHubTransaction.RESULT_FAILED_UNKNOWN -> "RESULT_FAILED_UNKNOWN";
+ case ContextHubTransaction.RESULT_FAILED_BAD_PARAMS -> "RESULT_FAILED_BAD_PARAMS";
+ case ContextHubTransaction.RESULT_FAILED_UNINITIALIZED -> "RESULT_FAILED_UNINITIALIZED";
+ case ContextHubTransaction.RESULT_FAILED_BUSY -> "RESULT_FAILED_BUSY";
+ case ContextHubTransaction.RESULT_FAILED_AT_HUB -> "RESULT_FAILED_AT_HUB";
+ case ContextHubTransaction.RESULT_FAILED_TIMEOUT -> "RESULT_FAILED_TIMEOUT";
+ case ContextHubTransaction.RESULT_FAILED_SERVICE_INTERNAL_FAILURE ->
+ "RESULT_FAILED_SERVICE_INTERNAL_FAILURE";
+ case ContextHubTransaction.RESULT_FAILED_HAL_UNAVAILABLE ->
+ "RESULT_FAILED_HAL_UNAVAILABLE";
+ default -> "UNKNOWN_RESULT";
+ };
}
/**
diff --git a/java/test/utils/src/com/google/android/utils/chre/ChreApiTestUtil.java b/java/test/utils/src/com/google/android/utils/chre/ChreApiTestUtil.java
index 75e56d4..c01b020 100644
--- a/java/test/utils/src/com/google/android/utils/chre/ChreApiTestUtil.java
+++ b/java/test/utils/src/com/google/android/utils/chre/ChreApiTestUtil.java
@@ -548,7 +548,7 @@
*/
public static void writeDataToFile(byte[] data, String filename,
Context context) throws Exception {
- File file = new File(context.getExternalFilesDir(null), filename);
+ File file = new File(context.getFilesDir(), filename);
ByteSink sink = Files.asByteSink(file);
sink.write(data);
}
diff --git a/java/test/utils/src/com/google/android/utils/chre/ContextHubBroadcastReceiver.java b/java/test/utils/src/com/google/android/utils/chre/ContextHubBroadcastReceiver.java
index 3a34d4f..e626b1a 100644
--- a/java/test/utils/src/com/google/android/utils/chre/ContextHubBroadcastReceiver.java
+++ b/java/test/utils/src/com/google/android/utils/chre/ContextHubBroadcastReceiver.java
@@ -51,7 +51,7 @@
}
Log.d(TAG, "Received intent event: " + event);
- Assert.assertEquals("Received too many Intent events", sQueue.size(), 0);
+ Assert.assertEquals("Received too many Intent events", /* expected= */ 0, sQueue.size());
sQueue.add(event);
}
diff --git a/java/test/utils/src/com/google/android/utils/chre/ContextHubServiceTestHelper.java b/java/test/utils/src/com/google/android/utils/chre/ContextHubServiceTestHelper.java
index 18623a0..9bd5899 100644
--- a/java/test/utils/src/com/google/android/utils/chre/ContextHubServiceTestHelper.java
+++ b/java/test/utils/src/com/google/android/utils/chre/ContextHubServiceTestHelper.java
@@ -26,8 +26,6 @@
import android.hardware.location.ContextHubTransaction;
import android.hardware.location.NanoAppBinary;
import android.hardware.location.NanoAppState;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
import java.util.HashMap;
import java.util.List;
@@ -65,18 +63,6 @@
registerHubResetClient();
}
- public void initAndUnloadAllNanoApps() throws InterruptedException, TimeoutException {
- init();
-
- // We only need to unload all nanoapps when the device has version < U, so the
- // tests remain the same on those devices. On newer devices, test mode will
- // handle this.
- if (VERSION.SDK_INT < VERSION_CODES.UPSIDE_DOWN_CAKE) {
- // Unload all nanoapps to ensure test starts at a clean state.
- unloadAllNanoApps();
- }
- }
-
public void deinit() {
// unregister to detect any hub reset.
unregisterHubResetClient();
diff --git a/pal/CMakeLists.txt b/pal/CMakeLists.txt
new file mode 100644
index 0000000..b8d562d
--- /dev/null
+++ b/pal/CMakeLists.txt
@@ -0,0 +1,99 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+include(backend.cmake)
+
+pw_add_facade(chre.pal.audio INTERFACE
+ BACKEND
+ chre.pal.audio_BACKEND
+ HEADERS
+ include/chre/pal/audio.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
+
+pw_add_facade(chre.pal.ble INTERFACE
+ BACKEND
+ chre.pal.ble_BACKEND
+ HEADERS
+ include/chre/pal/ble.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
+
+pw_add_facade(chre.pal.gnss INTERFACE
+ BACKEND
+ chre.pal.gnss_BACKEND
+ HEADERS
+ include/chre/pal/gnss.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
+
+pw_add_facade(chre.pal.sensor INTERFACE
+ BACKEND
+ chre.pal.sensor_BACKEND
+ HEADERS
+ include/chre/pal/sensor.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
+
+pw_add_library(chre.pal.system INTERFACE
+ HEADERS
+ include/chre/pal/system.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+)
+
+pw_add_library(chre.pal.version INTERFACE
+ HEADERS
+ include/chre/pal/version.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.pal.version
+)
+
+pw_add_facade(chre.pal.wifi INTERFACE
+ BACKEND
+ chre.pal.wifi_BACKEND
+ HEADERS
+ include/chre/pal/wifi.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
+
+pw_add_facade(chre.pal.wwan INTERFACE
+ BACKEND
+ chre.pal.wwan_BACKEND
+ HEADERS
+ include/chre/pal/wwan.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ chre.pal.version
+ chre.chre_api
+)
diff --git a/pal/backend.cmake b/pal/backend.cmake
new file mode 100644
index 0000000..9a4c871
--- /dev/null
+++ b/pal/backend.cmake
@@ -0,0 +1,21 @@
+include_guard(GLOBAL)
+
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+# Backend for chre.pal.audio.
+pw_add_backend_variable(chre.pal.audio_BACKEND)
+
+# Backend for chre.pal.ble.
+pw_add_backend_variable(chre.pal.ble_BACKEND)
+
+# Backend for chre.pal.gnss.
+pw_add_backend_variable(chre.pal.gnss_BACKEND)
+
+# Backend for chre.pal.sensor.
+pw_add_backend_variable(chre.pal.sensor_BACKEND)
+
+# Backend for chre.pal.wifi.
+pw_add_backend_variable(chre.pal.wifi_BACKEND)
+
+# Backend for chre.pal.wwan.
+pw_add_backend_variable(chre.pal.wwan_BACKEND)
diff --git a/platform/CMakeLists.txt b/platform/CMakeLists.txt
new file mode 100644
index 0000000..7f2d2a9
--- /dev/null
+++ b/platform/CMakeLists.txt
@@ -0,0 +1,342 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+include(backend.cmake)
+
+add_subdirectory(arm)
+add_subdirectory(freertos)
+add_subdirectory(shared)
+
+pw_add_facade(chre.platform.assert INTERFACE
+ BACKEND
+ chre.platform.assert_BACKEND
+ HEADERS
+ include/chre/platform/assert.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.platform.log
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.atomic INTERFACE
+ BACKEND
+ chre.platform.atomic_BACKEND
+ HEADERS
+ include/chre/platform/atomic.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.condition_variable INTERFACE
+ BACKEND
+ chre.platform.condition_variable_BACKEND
+ HEADERS
+ include/chre/platform/condition_variable.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.platform.mutex
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.context INTERFACE
+ BACKEND
+ chre.platform.context_BACKEND
+ HEADERS
+ include/chre/platform/context.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.fatal_error INTERFACE
+ BACKEND
+ chre.platform.fatal_error_BACKEND
+ HEADERS
+ include/chre/platform/fatal_error.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.platform.log
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.host_link INTERFACE
+ BACKEND
+ chre.platform.host_link_BACKEND
+ HEADERS
+ include/chre/platform/host_link.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.log INTERFACE
+ BACKEND
+ chre.platform.log_BACKEND
+ HEADERS
+ include/chre/platform/log.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.memory INTERFACE
+ BACKEND
+ chre.platform.memory_BACKEND
+ HEADERS
+ include/chre/platform/memory.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.memory_manager INTERFACE
+ BACKEND
+ chre.platform.memory_manager_BACKEND
+ HEADERS
+ include/chre/platform/heap_block_header.h
+ include/chre/platform/memory_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.core
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.mutex INTERFACE
+ BACKEND
+ chre.platform.mutex_BACKEND
+ HEADERS
+ include/chre/platform/mutex.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.notifier INTERFACE
+ BACKEND
+ chre.platform.notifier_BACKEND
+ HEADERS
+ include/chre/platform/notifier.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_audio INTERFACE
+ BACKEND
+ chre.platform.platform_audio_BACKEND
+ HEADERS
+ include/chre/platform/platform_audio.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.chre_api
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_ble INTERFACE
+ BACKEND
+ chre.platform.platform_ble_BACKEND
+ HEADERS
+ include/chre/platform/platform_ble.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_debug_dump_manager INTERFACE
+ BACKEND
+ chre.platform.platform_debug_dump_manager_BACKEND
+ HEADERS
+ include/chre/platform/platform_debug_dump_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.chre_api
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_gnss INTERFACE
+ BACKEND
+ chre.platform.platform_gnss_BACKEND
+ HEADERS
+ include/chre/platform/platform_gnss.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_nanoapp INTERFACE
+ BACKEND
+ chre.platform.platform_nanoapp_BACKEND
+ HEADERS
+ include/chre/platform/platform_nanoapp.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_sensor INTERFACE
+ BACKEND
+ chre.platform.platform_sensor_BACKEND
+ HEADERS
+ include/chre/platform/platform_sensor.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.platform.fatal_error
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_sensor_manager INTERFACE
+ BACKEND
+ chre.platform.platform_sensor_manager_BACKEND
+ HEADERS
+ include/chre/platform/platform_sensor_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_sensor_type_helpers INTERFACE
+ BACKEND
+ chre.platform.platform_sensor_type_helpers_BACKEND
+ HEADERS
+ include/chre/platform/platform_sensor_type_helpers.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_wifi INTERFACE
+ BACKEND
+ chre.platform.platform_wifi_BACKEND
+ HEADERS
+ include/chre/platform/platform_wifi.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.platform_wwan INTERFACE
+ BACKEND
+ chre.platform.platform_wwan_BACKEND
+ HEADERS
+ include/chre/platform/platform_wwan.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.power_control_manager INTERFACE
+ BACKEND
+ chre.platform.power_control_manager_BACKEND
+ HEADERS
+ include/chre/platform/power_control_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.static_nanoapp_init INTERFACE
+ BACKEND
+ chre.platform.static_nanoapp_init_BACKEND
+ HEADERS
+ include/chre/platform/static_nanoapp_init.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.system_time INTERFACE
+ BACKEND
+ chre.platform.system_time_BACKEND
+ HEADERS
+ include/chre/platform/system_time.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.system_timer INTERFACE
+ BACKEND
+ chre.platform.system_timer_BACKEND
+ HEADERS
+ include/chre/platform/system_timer.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.thread_handle INTERFACE
+ BACKEND
+ chre.platform.thread_handle_BACKEND
+ HEADERS
+ include/chre/platform/thread_handle.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.tracing INTERFACE
+ BACKEND
+ chre.platform.tracing_BACKEND
+ HEADERS
+ include/chre/platform/tracing.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.version INTERFACE
+ BACKEND
+ chre.platform.version_BACKEND
+ HEADERS
+ include/chre/platform/version.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
diff --git a/platform/arm/CMakeLists.txt b/platform/arm/CMakeLists.txt
new file mode 100644
index 0000000..a7fda77
--- /dev/null
+++ b/platform/arm/CMakeLists.txt
@@ -0,0 +1,8 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+pw_add_library(chre.platform.arm.nanoapp_loader STATIC
+ SOURCES
+ nanoapp_loader.cc
+ PRIVATE_DEPS
+ chre.platform.shared.nanoapp_loader.facade
+)
diff --git a/platform/backend.cmake b/platform/backend.cmake
new file mode 100644
index 0000000..91d0712
--- /dev/null
+++ b/platform/backend.cmake
@@ -0,0 +1,87 @@
+include_guard(GLOBAL)
+
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+# Backend for chre.platform.assert.
+pw_add_backend_variable(chre.platform.assert_BACKEND)
+
+# Backend for chre.platform.atomic.
+pw_add_backend_variable(chre.platform.atomic_BACKEND)
+
+# Backend for chre.platform.condition_variable.
+pw_add_backend_variable(chre.platform.condition_variable_BACKEND)
+
+# Backend for chre.platform.context.
+pw_add_backend_variable(chre.platform.context_BACKEND)
+
+# Backend for chre.platform.fatal_error.
+pw_add_backend_variable(chre.platform.fatal_error_BACKEND)
+
+# Backend for chre.platform.host_link.
+pw_add_backend_variable(chre.platform.host_link_BACKEND)
+
+# Backend for chre.platform.log.
+pw_add_backend_variable(chre.platform.log_BACKEND)
+
+# Backend for chre.platform.memory.
+pw_add_backend_variable(chre.platform.memory_BACKEND)
+
+# Backend for chre.platform.memory_manager.
+pw_add_backend_variable(chre.platform.memory_manager_BACKEND)
+
+# Backend for chre.platform.mutex.
+pw_add_backend_variable(chre.platform.mutex_BACKEND)
+
+# Backend for chre.platform.notifier.
+pw_add_backend_variable(chre.platform.notifier_BACKEND)
+
+# Backend for chre.platform.platform_audio.
+pw_add_backend_variable(chre.platform.platform_audio_BACKEND)
+
+# Backend for chre.platform.platform_ble.
+pw_add_backend_variable(chre.platform.platform_ble_BACKEND)
+
+# Backend for chre.platform.platform_debug_dump_manager.
+pw_add_backend_variable(chre.platform.platform_debug_dump_manager_BACKEND)
+
+# Backend for chre.platform.platform_gnss.
+pw_add_backend_variable(chre.platform.platform_gnss_BACKEND)
+
+# Backend for chre.platform.platform_nanoapp.
+pw_add_backend_variable(chre.platform.platform_nanoapp_BACKEND)
+
+# Backend for chre.platform.platform_sensor.
+pw_add_backend_variable(chre.platform.platform_sensor_BACKEND)
+
+# Backend for chre.platform.platform_sensor_manager.
+pw_add_backend_variable(chre.platform.platform_sensor_manager_BACKEND)
+
+# Backend for chre.platform.platform_sensor_type_helpers.
+pw_add_backend_variable(chre.platform.platform_sensor_type_helpers_BACKEND)
+
+# Backend for chre.platform.platform_wifi.
+pw_add_backend_variable(chre.platform.platform_wifi_BACKEND)
+
+# Backend for chre.platform.platform_wwan.
+pw_add_backend_variable(chre.platform.platform_wwan_BACKEND)
+
+# Backend for chre.platform.power_control_manager.
+pw_add_backend_variable(chre.platform.power_control_manager_BACKEND)
+
+# Backend for chre.platform.static_nanoapp_init.
+pw_add_backend_variable(chre.platform.static_nanoapp_init_BACKEND)
+
+# Backend for chre.platform.system_time.
+pw_add_backend_variable(chre.platform.system_time_BACKEND)
+
+# Backend for chre.platform.system_timer.
+pw_add_backend_variable(chre.platform.system_timer_BACKEND)
+
+# Backend for chre.platform.thread_handle.
+pw_add_backend_variable(chre.platform.thread_handle_BACKEND)
+
+# Backend for chre.platform.tracing.
+pw_add_backend_variable(chre.platform.tracing_BACKEND)
+
+# Backend for chre.platform.version.
+pw_add_backend_variable(chre.platform.version_BACKEND)
diff --git a/platform/exynos/host_link.cc b/platform/exynos/host_link.cc
index 92629f2..5dfa7ce 100644
--- a/platform/exynos/host_link.cc
+++ b/platform/exynos/host_link.cc
@@ -221,4 +221,14 @@
LOGE("NAN unsupported.");
}
+void HostMessageHandlers::handleBtSocketOpen(
+ uint16_t /* hostClientId */, uint64_t /* socketId */,
+ const char * /* name */, uint64_t /* endpointId */, uint64_t /* hubId */,
+ uint32_t /* aclConnectionHandle */, uint32_t /* localCid */,
+ uint32_t /* remoteCid */, uint32_t /* psm */, uint32_t /* localMtu */,
+ uint32_t /* remoteMtu */, uint32_t /* localMps */, uint32_t /* remoteMps */,
+ uint32_t /* initialRxCredits */, uint32_t /* initialTxCredits */) {
+ LOGE("BT Socket offload not supported");
+}
+
} // namespace chre
diff --git a/platform/exynos/platform_cache_management.cc b/platform/exynos/platform_cache_management.cc
index 975fe79..7f3a65c 100644
--- a/platform/exynos/platform_cache_management.cc
+++ b/platform/exynos/platform_cache_management.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "chre/target_platform/platform_cache_management.h"
+#include "chre/platform/shared/platform_cache_management.h"
namespace chre {
diff --git a/platform/freertos/CMakeLists.txt b/platform/freertos/CMakeLists.txt
new file mode 100644
index 0000000..ab464ee
--- /dev/null
+++ b/platform/freertos/CMakeLists.txt
@@ -0,0 +1,25 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+pw_add_library(chre.platform.freertos.platform_nanoapp STATIC
+ HEADERS
+ public_platform_nanoapp/chre/target_platform/platform_nanoapp_base.h
+ PUBLIC_INCLUDES
+ public_platform_nanoapp
+ PUBLIC_DEPS
+ chre.platform.shared.memory
+ chre.platform.shared.nanoapp_support_lib_dso
+ SOURCES
+ platform_nanoapp.cc
+ PRIVATE_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.host_link
+ chre.platform.log
+ chre.platform.platform_nanoapp.facade
+ chre.platform.shared.authentication
+ chre.platform.shared.dlfcn
+ chre.platform.shared.nanoapp_dso_util
+ chre.platform.shared.nanoapp_loader
+ chre.util
+ chre.util.system
+)
diff --git a/platform/freertos/include/chre/target_platform/init.h b/platform/freertos/include/chre/target_platform/init.h
new file mode 120000
index 0000000..e90376d
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/init.h
@@ -0,0 +1 @@
+../../../public_init/chre/target_platform/init.h
\ No newline at end of file
diff --git a/platform/freertos/include/chre/target_platform/mutex_base.h b/platform/freertos/include/chre/target_platform/mutex_base.h
new file mode 120000
index 0000000..243ec1b
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/mutex_base.h
@@ -0,0 +1 @@
+../../../public_mutex/chre/target_platform/mutex_base.h
\ No newline at end of file
diff --git a/platform/freertos/include/chre/target_platform/mutex_base_impl.h b/platform/freertos/include/chre/target_platform/mutex_base_impl.h
new file mode 120000
index 0000000..8cb1b7a
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/mutex_base_impl.h
@@ -0,0 +1 @@
+../../../public_mutex/chre/target_platform/mutex_base_impl.h
\ No newline at end of file
diff --git a/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h b/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h
new file mode 120000
index 0000000..6628c23
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h
@@ -0,0 +1 @@
+../../../public_platform_nanoapp/chre/target_platform/platform_nanoapp_base.h
\ No newline at end of file
diff --git a/platform/freertos/include/chre/target_platform/static_nanoapp_init.h b/platform/freertos/include/chre/target_platform/static_nanoapp_init.h
new file mode 120000
index 0000000..5302945
--- /dev/null
+++ b/platform/freertos/include/chre/target_platform/static_nanoapp_init.h
@@ -0,0 +1 @@
+../../../public_static_nanoapp_init/chre/target_platform/static_nanoapp_init.h
\ No newline at end of file
diff --git a/platform/freertos/include/chre/target_platform/init.h b/platform/freertos/public_init/chre/target_platform/init.h
similarity index 100%
rename from platform/freertos/include/chre/target_platform/init.h
rename to platform/freertos/public_init/chre/target_platform/init.h
diff --git a/platform/freertos/include/chre/target_platform/mutex_base.h b/platform/freertos/public_mutex/chre/target_platform/mutex_base.h
similarity index 100%
rename from platform/freertos/include/chre/target_platform/mutex_base.h
rename to platform/freertos/public_mutex/chre/target_platform/mutex_base.h
diff --git a/platform/freertos/include/chre/target_platform/mutex_base_impl.h b/platform/freertos/public_mutex/chre/target_platform/mutex_base_impl.h
similarity index 100%
rename from platform/freertos/include/chre/target_platform/mutex_base_impl.h
rename to platform/freertos/public_mutex/chre/target_platform/mutex_base_impl.h
diff --git a/platform/freertos/include/chre/target_platform/platform_nanoapp_base.h b/platform/freertos/public_platform_nanoapp/chre/target_platform/platform_nanoapp_base.h
similarity index 100%
rename from platform/freertos/include/chre/target_platform/platform_nanoapp_base.h
rename to platform/freertos/public_platform_nanoapp/chre/target_platform/platform_nanoapp_base.h
diff --git a/platform/freertos/include/chre/target_platform/static_nanoapp_init.h b/platform/freertos/public_static_nanoapp_init/chre/target_platform/static_nanoapp_init.h
similarity index 100%
rename from platform/freertos/include/chre/target_platform/static_nanoapp_init.h
rename to platform/freertos/public_static_nanoapp_init/chre/target_platform/static_nanoapp_init.h
diff --git a/platform/include/chre/platform/event_loop_hooks.h b/platform/include/chre/platform/event_loop_hooks.h
new file mode 100644
index 0000000..8756c79
--- /dev/null
+++ b/platform/include/chre/platform/event_loop_hooks.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_PLATFORM_EVENT_LOOP_HOOKS_H_
+#define CHRE_PLATFORM_EVENT_LOOP_HOOKS_H_
+
+/**
+ * @file
+ * Include a platform-specific event-loop configuration header if it exists.
+ * This header can optionally override the default macros defined below.
+ *
+ * TODO(b/380327627): Move the conentents of this file to chre/variant/config.h
+ * once CHRE team migrates platforms to use the variant config pattern and
+ * they address b/376532038.
+ */
+#ifdef CHRE_PLATFORM_EVENT_LOOP_CONFIG_HEADER
+#include CHRE_PLATFORM_EVENT_LOOP_CONFIG_HEADER
+#endif // CHRE_PLATFORM_EVENT_LOOP_CONFIG_HEADER
+
+/**
+ * @param eventLoop Pointer to the current EventLoop instance that is used to
+ * deliver events to nanoapps.
+ * @param eventType Event type identifier, which implies the type of eventData
+ * @param eventData The data that failed to be posted
+ * @param freeCallback Function to invoke to when the event has been processed
+ * by all recipients; this must be safe to call immediately, to handle
+ * the case where CHRE is shutting down
+ * @param senderInstanceId The instance ID of the sender of this event
+ * @param targetInstanceId targetInstanceId The instance ID of the destination
+ * of this event
+ * @param targetGroupMask Mask used to limit the recipients that are
+ * registered to receive this event
+ *
+ * @since v1.11
+ * @note FATAL_ERROR is called after this macro is executed
+ */
+#ifndef CHRE_HANDLE_FAILED_SYSTEM_EVENT_ENQUEUE
+#define CHRE_HANDLE_FAILED_SYSTEM_EVENT_ENQUEUE( \
+ eventLoop, eventType, eventData, freeCallback, senderInstanceId, \
+ targetInstanceId, targetGroupMask) \
+ do { \
+ } while (0)
+#endif // !CHRE_HANDLE_FAILED_SYSTEM_EVENT_ENQUEUE
+
+/**
+ * @param eventLoop Pointer to the current EventLoop instance that is used to
+ * deliver events to nanoapps.
+ * @param eventType Event type identifier, which implies the type of eventData
+ * @param eventData The data that failed to be posted
+ * @param callback Function to invoke from the context of the CHRE thread
+ * @param extraData Additional arbitrary data to provide to the callback
+ *
+ * @since v1.11
+ * @note FATAL_ERROR is called after this macro is executed
+ */
+#ifndef CHRE_HANDLE_EVENT_QUEUE_FULL_DURING_SYSTEM_POST
+#define CHRE_HANDLE_EVENT_QUEUE_FULL_DURING_SYSTEM_POST( \
+ eventLoop, eventType, eventData, callback, extraData) \
+ do { \
+ } while (0)
+#endif // !CHRE_HANDLE_EVENT_QUEUE_FULL_DURING_SYSTEM_POST
+
+/**
+ * @param eventLoop Pointer to the current EventLoop instance that is used to
+ * deliver events to nanoapps.
+ * @param eventType Event type identifier, which implies the type of eventData
+ * @param eventData The data that failed to be posted
+ * @param freeCallback Function to invoke to when the event has been processed
+ * by all recipients; this must be safe to call immediately, to handle
+ * the case where CHRE is shutting down
+ * @param senderInstanceId The instance ID of the sender of this event
+ * @param targetInstanceId targetInstanceId The instance ID of the destination
+ * of this event
+ * @param targetGroupMask Mask used to limit the recipients that are
+ * registered to receive this event
+ *
+ * @since v1.11
+ * @note Upon return, the freeCallaback will be invoked if not nullptr.
+ */
+#ifndef CHRE_HANDLE_LOW_PRIORITY_ENQUEUE_FAILURE
+#define CHRE_HANDLE_LOW_PRIORITY_ENQUEUE_FAILURE( \
+ eventLoop, eventType, eventData, freeCallback, senderInstanceId, \
+ targetInstanceId, targetGroupMask) \
+ do { \
+ } while (0)
+#endif // !CHRE_HANDLE_LOW_PRIORITY_ENQUEUE_FAILURE
+
+#endif // CHRE_PLATFORM_EVENT_LOOP_HOOKS_H_
diff --git a/platform/include/chre/platform/host_link.h b/platform/include/chre/platform/host_link.h
index 0d5b7b4..2bf5464 100644
--- a/platform/include/chre/platform/host_link.h
+++ b/platform/include/chre/platform/host_link.h
@@ -93,4 +93,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/host_link_impl.h")
+#include "chre/target_platform/host_link_impl.h"
+#endif // __has_include("chre/target_platform/host_link_impl.h")
+
#endif // CHRE_PLATFORM_HOST_LINK_H_
diff --git a/platform/include/chre/platform/memory_manager.h b/platform/include/chre/platform/memory_manager.h
index 48c1881..e7906df 100644
--- a/platform/include/chre/platform/memory_manager.h
+++ b/platform/include/chre/platform/memory_manager.h
@@ -21,9 +21,9 @@
#include <cstdint>
#include "chre/core/nanoapp.h"
+#include "chre/platform/heap_block_header.h"
#include "chre/util/non_copyable.h"
#include "chre/util/system/debug_dump.h"
-#include "heap_block_header.h"
// This default value can be overridden in the variant-specific makefile.
#ifndef CHRE_MAX_ALLOCATION_BYTES
@@ -140,4 +140,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/memory_manager_impl.h")
+#include "chre/target_platform/memory_manager_impl.h"
+#endif // __has_include("chre/target_platform/memory_manager_impl.h")
+
#endif // CHRE_PLATFORM_MEMORY_MANAGER_H_
diff --git a/platform/include/chre/platform/platform_audio.h b/platform/include/chre/platform/platform_audio.h
index 3f20115..353d6d9 100644
--- a/platform/include/chre/platform/platform_audio.h
+++ b/platform/include/chre/platform/platform_audio.h
@@ -129,4 +129,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_audio_impl.h")
+#include "chre/target_platform/platform_audio_impl.h"
+#endif // __has_include("chre/target_platform/platform_audio_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_AUDIO_H_
diff --git a/platform/include/chre/platform/platform_ble.h b/platform/include/chre/platform/platform_ble.h
index fdb495f..8574b77 100644
--- a/platform/include/chre/platform/platform_ble.h
+++ b/platform/include/chre/platform/platform_ble.h
@@ -120,4 +120,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_ble_impl.h")
+#include "chre/target_platform/platform_ble_impl.h"
+#endif // __has_include("chre/target_platform/platform_ble_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_BLE_H_
diff --git a/platform/include/chre/platform/platform_debug_dump_manager.h b/platform/include/chre/platform/platform_debug_dump_manager.h
index 89b2dce..3a665db 100644
--- a/platform/include/chre/platform/platform_debug_dump_manager.h
+++ b/platform/include/chre/platform/platform_debug_dump_manager.h
@@ -66,4 +66,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_debug_dump_manager_impl.h")
+#include "chre/target_platform/platform_debug_dump_manager_impl.h"
+#endif // __has_include("chre/target_platform/platform_debug_dump_manager_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_DEBUG_DUMP_MANAGER_H_
diff --git a/platform/include/chre/platform/platform_gnss.h b/platform/include/chre/platform/platform_gnss.h
index c922f5e..2bc7cfb 100644
--- a/platform/include/chre/platform/platform_gnss.h
+++ b/platform/include/chre/platform/platform_gnss.h
@@ -95,4 +95,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_gnss_impl.h")
+#include "chre/target_platform/platform_gnss_impl.h"
+#endif // __has_include("chre/target_platform/platform_gnss_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_GNSS_H_
diff --git a/platform/include/chre/platform/platform_nanoapp.h b/platform/include/chre/platform/platform_nanoapp.h
index 817226c..7d9e736 100644
--- a/platform/include/chre/platform/platform_nanoapp.h
+++ b/platform/include/chre/platform/platform_nanoapp.h
@@ -135,4 +135,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_nanoapp_impl.h")
+#include "chre/target_platform/platform_nanoapp_impl.h"
+#endif // __has_include("chre/target_platform/platform_nanoapp_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_NANOAPP_H_
diff --git a/platform/include/chre/platform/platform_sensor.h b/platform/include/chre/platform/platform_sensor.h
index 277afb5..fa0a75d 100644
--- a/platform/include/chre/platform/platform_sensor.h
+++ b/platform/include/chre/platform/platform_sensor.h
@@ -92,4 +92,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_sensor_impl.h")
+#include "chre/target_platform/platform_sensor_impl.h"
+#endif // __has_include("chre/target_platform/platform_sensor_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_SENSOR_H_
diff --git a/platform/include/chre/platform/platform_sensor_manager.h b/platform/include/chre/platform/platform_sensor_manager.h
index ded9859..a3c0fb6 100644
--- a/platform/include/chre/platform/platform_sensor_manager.h
+++ b/platform/include/chre/platform/platform_sensor_manager.h
@@ -18,7 +18,6 @@
#define CHRE_PLATFORM_PLATFORM_SENSOR_MANAGER_H_
#include "chre/core/sensor.h"
-#include "chre/pal/sensor.h"
#include "chre/target_platform/platform_sensor_manager_base.h"
#include "chre/util/dynamic_vector.h"
@@ -155,4 +154,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_sensor_manager_impl.h")
+#include "chre/target_platform/platform_sensor_manager_impl.h"
+#endif // __has_include("chre/target_platform/platform_sensor_manager_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_SENSOR_MANAGER_H_
diff --git a/platform/include/chre/platform/platform_sensor_type_helpers.h b/platform/include/chre/platform/platform_sensor_type_helpers.h
index a396897..7afb88b 100644
--- a/platform/include/chre/platform/platform_sensor_type_helpers.h
+++ b/platform/include/chre/platform/platform_sensor_type_helpers.h
@@ -79,4 +79,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_sensor_type_helpers_impl.h")
+#include "chre/target_platform/platform_sensor_type_helpers_impl.h"
+#endif // __has_include("chre/target_platform/platform_sensor_type_helpers_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_SENSOR_TYPE_HELPERS_H_
diff --git a/platform/include/chre/platform/platform_wifi.h b/platform/include/chre/platform/platform_wifi.h
index fc7a545..1692575 100644
--- a/platform/include/chre/platform/platform_wifi.h
+++ b/platform/include/chre/platform/platform_wifi.h
@@ -129,4 +129,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_wifi_impl.h")
+#include "chre/target_platform/platform_wifi_impl.h"
+#endif // __has_include("chre/target_platform/platform_wifi_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_WIFI_H_
diff --git a/platform/include/chre/platform/platform_wwan.h b/platform/include/chre/platform/platform_wwan.h
index bed6449..e22ad55 100644
--- a/platform/include/chre/platform/platform_wwan.h
+++ b/platform/include/chre/platform/platform_wwan.h
@@ -64,4 +64,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/platform_wwan_impl.h")
+#include "chre/target_platform/platform_wwan_impl.h"
+#endif // __has_include("chre/target_platform/platform_wwan_impl.h")
+
#endif // CHRE_PLATFORM_PLATFORM_WWAN_H_
diff --git a/platform/include/chre/platform/power_control_manager.h b/platform/include/chre/platform/power_control_manager.h
index 6b3566b..963718c 100644
--- a/platform/include/chre/platform/power_control_manager.h
+++ b/platform/include/chre/platform/power_control_manager.h
@@ -52,4 +52,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/power_control_manager_impl.h")
+#include "chre/target_platform/power_control_manager_impl.h"
+#endif // __has_include("chre/target_platform/power_control_manager_impl.h")
+
#endif // CHRE_PLATFORM_POWER_CONTROL_MANAGER_H
diff --git a/platform/include/chre/platform/system_time.h b/platform/include/chre/platform/system_time.h
index ac58e50..a25bd02 100644
--- a/platform/include/chre/platform/system_time.h
+++ b/platform/include/chre/platform/system_time.h
@@ -66,4 +66,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/system_time_impl.h")
+#include "chre/target_platform/system_time_impl.h"
+#endif // __has_include("chre/target_platform/system_time_impl.h")
+
#endif // CHRE_PLATFORM_TIME_H_
diff --git a/platform/include/chre/platform/system_timer.h b/platform/include/chre/platform/system_timer.h
index 08160d2..7a4e459 100644
--- a/platform/include/chre/platform/system_timer.h
+++ b/platform/include/chre/platform/system_timer.h
@@ -107,4 +107,9 @@
} // namespace chre
+/* The platform can optionally provide an inlined implementation */
+#if __has_include("chre/target_platform/system_timer_impl.h")
+#include "chre/target_platform/system_timer_impl.h"
+#endif // __has_include("chre/target_platform/system_timer_impl.h")
+
#endif // CHRE_PLATFORM_SYSTEM_TIMER_H_
diff --git a/platform/platform.mk b/platform/platform.mk
index 8e16753..8dd0d61 100644
--- a/platform/platform.mk
+++ b/platform/platform.mk
@@ -193,6 +193,11 @@
# Simulator-specific Compiler Flags ############################################
SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include
+SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_ble_pal
+SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_debug_dump_manager
+SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_gnss_pal
+SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_wifi_pal
+SIM_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_wwan_pal
SIM_CFLAGS += -Iplatform/linux/sim/include
# Simulator-specific Source Files ##############################################
@@ -342,6 +347,11 @@
# The order here is important so that the googletest target prefers shared,
# linux and then SLPI.
GOOGLETEST_CFLAGS += -Iplatform/shared/include
+GOOGLETEST_CFLAGS += -Iplatform/shared/public_platform_ble_pal
+GOOGLETEST_CFLAGS += -Iplatform/shared/public_platform_debug_dump_manager
+GOOGLETEST_CFLAGS += -Iplatform/shared/public_platform_gnss_pal
+GOOGLETEST_CFLAGS += -Iplatform/shared/public_platform_wifi_pal
+GOOGLETEST_CFLAGS += -Iplatform/shared/public_platform_wwan_pal
GOOGLETEST_CFLAGS += -Iplatform/linux/include
GOOGLETEST_CFLAGS += -Iplatform/slpi/include
GOOGLETEST_CFLAGS += -Iplatform/shared/pw_trace/include
@@ -513,6 +523,14 @@
TINYSYS_SRCS += $(CHRE_PREFIX)/platform/shared/platform_gnss.cc
endif
+ifeq ($(CHRE_WIFI_SUPPORT_ENABLED), true)
+TINYSYS_SRCS += platform/shared/platform_wifi.cc
+endif
+
+ifeq ($(CHRE_WWAN_SUPPORT_ENABLED), true)
+TINYSYS_SRCS += platform/shared/platform_wwan.cc
+endif
+
# Compiler flags
# Variables
@@ -523,6 +541,11 @@
TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/aligned_alloc_unsupported/include
TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include
TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/nanoapp/include
+TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_ble_pal
+TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_debug_dump_manager
+TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_gnss_pal
+TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_wifi_pal
+TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/public_platform_wwan_pal
TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/shared/include/chre/platform/shared/libc
TINYSYS_CFLAGS += -I$(CHRE_PREFIX)/platform/tinysys/include
diff --git a/platform/shared/CMakeLists.txt b/platform/shared/CMakeLists.txt
new file mode 100644
index 0000000..f6beab8
--- /dev/null
+++ b/platform/shared/CMakeLists.txt
@@ -0,0 +1,644 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+include(backend.cmake)
+
+pw_add_facade(chre.platform.shared.authentication INTERFACE
+ BACKEND
+ chre.platform.shared.authentication_BACKEND
+ HEADERS
+ include/chre/platform/shared/authentication.h
+ PUBLIC_INCLUDES
+ include
+)
+
+pw_add_facade(chre.platform.shared.bt_snoop_log INTERFACE
+ BACKEND
+ chre.platform.shared.bt_snoop_log_BACKEND
+ HEADERS
+ include/chre/platform/shared/bt_snoop_log.h
+ PUBLIC_INCLUDES
+ include
+)
+
+# Implements chre_api/chre/audio.h's:
+# - bool chreAudioGetSource(uint32_t handle,
+# struct chreAudioSource *audioSource)
+# - bool chreAudioConfigureSource(uint32_t handle, bool enable,
+# uint64_t bufferDuration,
+# uint64_t deliveryInterval)
+# - bool chreAudioGetStatus(uint32_t handle,
+# struct chreAudioSourceStatus *status)
+#
+pw_add_library(chre.platform.shared.chre_api_audio STATIC
+ SOURCES
+ chre_api_audio.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.platform.platform_audio
+ chre.util
+ chre.util.system
+)
+# Implements chre_api/chre/ble.h's:
+# - uint32_t chreBleGetCapabilities()
+# - uint32_t chreBleGetFilterCapabilities()
+# - bool chreBleFlushAsync(const void *cookie)
+# - bool chreBleStartScanAsync(chreBleScanMode mode,
+# uint32_t reportDelayMs,
+# const struct chreBleScanFilter *filter)
+# - bool chreBleStartScanAsyncV1_9(enum chreBleScanMode mode,
+# uint32_t reportDelayMs,
+# const struct chreBleScanFilterV1_9 *filter,
+# const void *cookie)
+# - bool chreBleStopScanAsync()
+# - bool chreBleStopScanAsyncV1_9(const void *cookie)
+# - bool chreBleReadRssiAsync(uint16_t connectionHandle,
+# const void *cookie)
+# - bool chreBleGetScanStatus(struct chreBleScanStatus *status)
+#
+pw_add_library(chre.platform.shared.chre_api_ble STATIC
+ SOURCES
+ chre_api_ble.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+ chre.util.system
+)
+
+# Implements chre_api/chre/event.h's:
+# - bool chreSendEvent(uint16_t eventType, void *eventData,
+# chreEventCompleteFunction *freeCallback,
+# uint32_t targetInstanceId)
+# - bool chreSendMessageToHost(void *message, uint32_t messageSize,
+# uint32_t messageType,
+# chreMessageFreeFunction *freeCallback)
+# - bool chreSendMessageToHostEndpoint(
+# void *message, size_t messageSize, uint32_t messageType,
+# uint16_t hostEndpoint, chreMessageFreeFunction *freeCallback)
+# - bool chreSendMessageWithPermissions(
+# void *message, size_t messageSize, uint32_t messageType,
+# uint16_t hostEndpoint, uint32_t messagePermissions,
+# chreMessageFreeFunction *freeCallback)
+# - bool chreSendReliableMessageAsync(
+# void *message, size_t messageSize, uint32_t messageType,
+# uint16_t hostEndpoint, uint32_t messagePermissions,
+# chreMessageFreeFunction *freeCallback, const void *cookie)
+# - bool chreGetNanoappInfoByAppId(uint64_t appId, struct chreNanoappInfo *info)
+# - bool chreGetNanoappInfoByInstanceId(uint32_t instanceId,
+# struct chreNanoappInfo *info)
+# - void chreConfigureNanoappInfoEvents(bool enable)
+# - void chreConfigureHostSleepStateEvents(bool enable)
+# - bool chreIsHostAwake()
+# - void chreConfigureDebugDumpEvent(bool enable)
+# - bool chreConfigureHostEndpointNotifications(uint16_t hostEndpointId,
+# bool enable)
+# - bool chrePublishRpcServices(struct chreNanoappRpcService *services,
+# size_t numServices)
+# - bool chreGetHostEndpointInfo(uint16_t hostEndpointId,
+# struct chreHostEndpointInfo *info)
+#
+pw_add_library(chre.platform.shared.chre_api_core STATIC
+ SOURCES
+ chre_api_core.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.platform.log
+ chre.util
+ chre.util.system
+)
+
+# Implements chre_api/chre/gnss.h's:
+# - uint32_t chreGnssGetCapabilities()
+# - bool chreGnssLocationSessionStartAsync(
+# uint32_t minIntervalMs, uint32_t minTimeToNextFixMs,
+# const void *cookie)
+# - bool chreGnssLocationSessionStopAsync(const void *cookie)
+# - bool chreGnssMeasurementSessionStartAsync(
+# uint32_t minIntervalMs, const void *cookie)
+# - bool chreGnssMeasurementSessionStopAsync(const void *cookie)
+# - bool chreGnssConfigurePassiveLocationListener(bool enable)
+#
+pw_add_library(chre.platform.shared.chre_api_gnss STATIC
+ SOURCES
+ chre_api_gnss.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+ chre.util.system
+)
+
+# Implements chre_api/chre/re.h's:
+# - uint32_t chreGetCapabilities()
+# - uint32_t chreGetMessageToHostMaxSize()
+# - uint64_t chreGetAppId(void)
+# - uint32_t chreGetInstanceId(void)
+# - uint64_t chreGetTime()
+# - int64_t chreGetEstimatedHostTimeOffset()
+# - uint32_t chreTimerSet(uint64_t duration, const void *cookie, bool oneShot)
+# - bool chreTimerCancel(uint32_t timerId)
+# - void chreAbort(uint32_t abortCode)
+# - void* chreHeapAlloc(uint32_t bytes)
+# - void chreHeapFree(void *ptr)
+# - chreDebugDumpLog(const char *formatStr, ...)
+#
+# Also provides:
+# - void platform_chreDebugDumpVaLog(const char *formatStr, va_list args)
+#
+# Does not provide:
+# - void chreLog(enum chreLogLevel level, const char *formatStr, ...)
+pw_add_library(chre.platform.shared.chre_api_re STATIC
+ HEADERS
+ include/chre/platform/shared/debug_dump.h
+ PUBLIC_INCLUDES
+ include
+ SOURCES
+ chre_api_re.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.platform.fatal_error
+ chre.util
+)
+
+# Implements chre_api/chre/sensor.h's:
+# - bool chreSensorFindDefault(uint8_t sensorType, uint32_t *handle)
+# - bool chreSensorFind(uint8_t sensorType, uint8_t sensorIndex,
+# uint32_t *handle)
+# - bool chreGetSensorInfo(uint32_t sensorHandle, struct chreSensorInfo *info)
+# - bool chreGetSensorSamplingStatus(uint32_t sensorHandle,
+# struct chreSensorSamplingStatus *status)
+# - bool chreSensorConfigure(uint32_t sensorHandle,
+# enum chreSensorConfigureMode mode,
+# uint64_t interval, uint64_t latency)
+# - bool chreSensorConfigureBiasEvents(uint32_t sensorHandle, bool enable)
+# - bool chreSensorGetThreeAxisBias(uint32_t sensorHandle,
+# struct chreSensorThreeAxisData *bias)
+# - bool chreSensorFlushAsync(uint32_t sensorHandle, const void *cookie)
+#
+pw_add_library(chre.platform.shared.chre_api_sensor STATIC
+ SOURCES
+ chre_api_sensor.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+)
+
+# Implements chre_api/chre/user_settings.h's:
+# - int8_t chreUserSettingGetState(uint8_t setting)
+# - void chreUserSettingConfigureEvents(uint8_t setting, bool enable)
+#
+pw_add_library(chre.platform.shared.chre_api_user_settings STATIC
+ SOURCES
+ chre_api_user_settings.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+)
+
+# Implements chre_api/chre/version.h's:
+# - uint32_t chreGetApiVersion(void)
+# - uint32_t chreGetVersion(void)
+# - uint64_t chreGetPlatformId(void)
+#
+pw_add_library(chre.platform.shared.chre_api_version STATIC
+ SOURCES
+ chre_api_version.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+)
+
+# Implements chre_api/chre/wifi.h's:
+# - uint32_t chreWifiGetCapabilities()
+# - bool chreWifiNanGetCapabilities(
+# struct chreWifiNanCapabilities *capabilities)
+# - bool chreWifiConfigureScanMonitorAsync(bool enable, const void *cookie)
+# - bool chreWifiRequestScanAsync(const struct chreWifiScanParams *params,
+# const void *cookie)
+# - bool chreWifiRequestRangingAsync(
+# const struct chreWifiRangingParams *params, const void *cookie)
+# - bool chreWifiNanSubscribe(struct chreWifiNanSubscribeConfig *config,
+# const void *cookie)
+# - bool chreWifiNanSubscribeCancel(uint32_t subscriptionId)
+# - bool chreWifiNanRequestRangingAsync(
+# const struct chreWifiNanRangingParams *params, const void *cookie)
+#
+pw_add_library(chre.platform.shared.chre_api_wifi STATIC
+ SOURCES
+ chre_api_wifi.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+ chre.util.system
+)
+
+# Implements chre_api/chre/wwan.h's:
+# - uint32_t chreWwanGetCapabilities()
+# - bool chreWwanGetCellInfoAsync(const void *cookie)
+#
+pw_add_library(chre.platform.shared.chre_api_wwan STATIC
+ SOURCES
+ chre_api_wwan.cc
+ PRIVATE_DEPS
+ chre.chre_api.facade
+ chre.core
+ chre.util
+ chre.util.system
+)
+
+pw_add_library(chre.platform.shared.dlfcn STATIC
+ HEADERS
+ include/chre/platform/shared/libc/dlfcn.h
+ PUBLIC_INCLUDES
+ include/chre/platform/shared/libc
+ SOURCES
+ dlfcn.cc
+ PRIVATE_DEPS
+ chre.platform.assert
+ chre.platform.log
+ chre.platform.shared.nanoapp_loader
+ chre.util
+)
+
+pw_add_library(chre.platform.shared.generated.host_messages_generated INTERFACE
+ HEADERS
+ include/chre/platform/shared/generated/host_messages_generated.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre_third_party.flatbuffers
+)
+
+pw_add_library(chre.platform.shared.host_protocol_chre STATIC
+ HEADERS
+ include/chre/platform/shared/host_protocol_chre.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.platform.shared.generated.host_messages_generated
+ chre.platform.shared.host_protocol_common
+ chre.util
+ chre.util.flatbuffers
+ chre.chre_api
+ chre_third_party.flatbuffers
+ SOURCES
+ host_protocol_chre.cc
+ host_link.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.platform.shared.host_protocol_chre
+ chre.platform.shared.nanoapp_load_manager
+)
+
+pw_add_library(chre.platform.shared.host_protocol_common STATIC
+ HEADERS
+ include/chre/platform/shared/host_protocol_common.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util.system
+ chre_third_party.flatbuffers
+ SOURCES
+ host_protocol_common.cc
+ PRIVATE_DEPS
+ chre.platform.shared.generated.host_messages_generated
+)
+
+pw_add_library(chre.platform.shared.loader_util INTERFACE
+ HEADERS
+ include/chre/platform/shared/loader_util.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.variant.config
+)
+
+pw_add_library(chre.platform.shared.log_buffer STATIC
+ HEADERS
+ include/chre/platform/shared/log_buffer.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.platform.mutex
+ chre.platform.shared.bt_snoop_log
+ chre.platform.shared.generated.host_messages_generated
+ SOURCES
+ log_buffer.cc
+ PRIVATE_DEPS
+ chre.platform.assert
+ chre.util
+)
+
+# This requires the backend to provide an implementation for:
+# - void LogBufferManager::preSecondaryBufferUse() const
+pw_add_facade(chre.platform.shared.log_buffer_manager STATIC
+ BACKEND
+ chre.platform.shared.log_buffer_manager_BACKEND
+ HEADERS
+ include/chre/platform/shared/log_buffer_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.condition_variable
+ chre.platform.mutex
+ chre.platform.shared.bt_snoop_log.facade
+ chre.platform.shared.generated.host_messages_generated
+ chre.platform.shared.log_buffer
+ chre.util
+ SOURCES
+ log_buffer_manager.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.util
+ pw_log_tokenized.config
+ pw_tokenizer
+)
+
+pw_add_facade(chre.platform.shared.memory INTERFACE
+ BACKEND
+ chre.platform.shared.memory_BACKEND
+ HEADERS
+ include/chre/platform/shared/memory.h
+ PUBLIC_INCLUDES
+ include
+)
+
+# Partial backend for chre.platform.memory_manger which implements:
+# 1) void *MemoryManager::nanoappAlloc(Nanoapp *app, uint32_t bytes)
+# 2) void MemoryManager::nanoappFree(Nanoapp *app, void *ptr)
+# 3) uint32_t MemoryManager::nanoappFreeAll(Nanoapp *app)
+# 4) void MemoryManager::logStateToBuffer(DebugDumpWrapper &debugDump) const
+pw_add_library(chre.platform.shared.memory_manager STATIC
+ SOURCES
+ memory_manager.cc
+ PRIVATE_DEPS
+ chre.platform.assert
+ chre.platform.memory_manager.facade
+ chre.util.system
+)
+
+pw_add_library(chre.platform.shared.nanoapp_dso_util STATIC
+ HEADERS
+ include/chre/platform/shared/nanoapp_dso_util.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.platform.shared.nanoapp_support_lib_dso
+ SOURCES
+ nanoapp/nanoapp_dso_util.cc
+ PRIVATE_DEPS
+ chre.platform.log
+)
+
+# This is itself a facade for:
+# 1) bool NanoappLoader::relocateTable(DynamicHeader *dyn, int tag)
+# 2) bool NanoappLoader::resolveGot()
+# 3) if CHREX_SYMBOL_EXTENSIONS is set, providing
+# `const ExportedData chre::kVendorExportedData[]` via
+# `chre/extensions/platform/symbol_list.h`.
+pw_add_facade(chre.platform.shared.nanoapp_loader STATIC
+ BACKEND
+ chre.platform.shared.nanoapp_loader_BACKEND
+ HEADERS
+ include/chre/platform/shared/nanoapp_loader.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.platform.shared.loader_util
+ SOURCES
+ nanoapp_loader.cc
+ PRIVATE_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.fatal_error
+ chre.platform.shared.chre_api_re
+ chre.platform.shared.dlfcn
+ chre.platform.shared.memory
+ chre.platform.shared.nanoapp_tokenized_log
+ chre.platform.shared.platform_cache_management
+ chre.variant.config
+)
+
+pw_add_library(chre.platform.shared.nanoapp_load_manager STATIC
+ HEADERS
+ include/chre/platform/shared/nanoapp_load_manager.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.core
+ chre.util
+ SOURCES
+ nanoapp_load_manager.cc
+)
+
+# Note that this does NOT actually implement, which are only required for
+# nanoapp builds:
+# - const struct chreNslNanoappInfo *getChreNslDsoNanoappInfo()
+# - bool chreNslDsoGetApi(uint32_t apiId, void **apiHandle)
+pw_add_library(chre.platform.shared.nanoapp_support_lib_dso INTERFACE
+ HEADERS
+ include/chre/platform/shared/nanoapp_support_lib_dso.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+)
+
+pw_add_library(chre.platform.shared.nanoapp_tokenized_log STATIC
+ HEADERS
+ nanoapp/include/chre/platform/shared/nanoapp/tokenized_log.h
+ PUBLIC_INCLUDES
+ nanoapp/include
+ PUBLIC_DEPS
+ chre.chre_api
+ SOURCES
+ tokenized_log.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.platform.shared.log_buffer_manager
+ pw_log_tokenized.config
+ pw_tokenizer
+)
+
+pw_add_library(chre.platform.shared.pal_audio_stub STATIC
+ SOURCES
+ pal_audio_stub.cc
+ PRIVATE_DEPS
+ chre.pal.audio.facade
+)
+
+pw_add_library(chre.platform.shared.pal_ble_stub STATIC
+ SOURCES
+ pal_ble_stub.cc
+ PRIVATE_DEPS
+ chre.pal.ble.facade
+)
+
+pw_add_library(chre.platform.shared.pal_gnss_stub STATIC
+ SOURCES
+ pal_gnss_stub.cc
+ PRIVATE_DEPS
+ chre.pal.gnss.facade
+)
+
+pw_add_library(chre.platform.shared.pal_sensor_stub STATIC
+ SOURCES
+ pal_sensor_stub.cc
+ PRIVATE_DEPS
+ chre.pal.sensor.facade
+)
+
+pw_add_facade(chre.platform.shared.pal_system_api STATIC
+ BACKEND
+ chre.platform.shared.pal_system_api_BACKEND
+ HEADERS
+ include/chre/platform/shared/pal_system_api.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.pal.system
+ SOURCES
+ pal_system_api.cc
+ PRIVATE_DEPS
+ chre.platform.log
+ chre.platform.memory
+ chre.platform.system_time
+)
+
+pw_add_library(chre.platform.shared.pal_wifi_stub STATIC
+ SOURCES
+ pal_wifi_stub.cc
+ PRIVATE_DEPS
+ chre.pal.wifi.facade
+)
+
+pw_add_library(chre.platform.shared.pal_wwan_stub STATIC
+ SOURCES
+ pal_wwan_stub.cc
+ PRIVATE_DEPS
+ chre.pal.wwan.facade
+)
+
+pw_add_library(chre.platform.shared.platform_ble_pal STATIC
+ HEADERS
+ public_platform_ble_pal/chre/target_platform/platform_ble_base.h
+ PUBLIC_INCLUDES
+ public_platform_ble_pal
+ PUBLIC_DEPS
+ chre.pal.ble
+ chre.platform.shared.platform_pal
+ SOURCES
+ platform_ble.cc
+ PRIVATE_DEPS
+ chre.chre_api
+ chre.core
+ chre.platform.log
+ chre.platform.platform_ble.facade
+ chre.platform.shared.bt_snoop_log
+ chre.platform.shared.pal_system_api
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.shared.platform_cache_management INTERFACE
+ BACKEND
+ chre.platform.shared.platform_cache_management_BACKEND
+ HEADERS
+ include/chre/platform/shared/platform_cache_management.h
+ PUBLIC_INCLUDES
+ include
+)
+
+# The optional CHPP and ASH integration is not supported.
+pw_add_library(chre.platform.shared.platform_debug_dump_manager STATIC
+ HEADERS
+ public_platform_debug_dump_manager/chre/target_platform/platform_debug_dump_manager_base.h
+ PUBLIC_INCLUDES
+ public_platform_debug_dump_manager
+ PUBLIC_DEPS
+ chre.variant.config
+ SOURCES
+ platform_debug_dump_manager.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.host_link
+ chre.platform.log
+ chre.platform.platform_debug_dump_manager.facade
+ chre.util
+)
+
+pw_add_library(chre.platform.shared.platform_gnss_pal STATIC
+ HEADERS
+ public_platform_gnss_pal/chre/target_platform/platform_gnss_base.h
+ PUBLIC_INCLUDES
+ public_platform_gnss_pal
+ PUBLIC_DEPS
+ chre.pal.gnss
+ chre.platform.shared.platform_pal
+ SOURCES
+ platform_gnss.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.platform.platform_gnss.facade
+ chre.platform.shared.pal_system_api
+ chre.variant.config
+)
+
+pw_add_facade(chre.platform.shared.platform_pal INTERFACE
+ BACKEND
+ chre.platform.shared.platform_pal_BACKEND
+ HEADERS
+ include/chre/platform/shared/platform_pal.h
+ PUBLIC_INCLUDES
+ include
+)
+
+pw_add_library(chre.platform.shared.platform_wifi_pal STATIC
+ HEADERS
+ public_platform_wifi_pal/chre/target_platform/platform_wifi_base.h
+ PUBLIC_INCLUDES
+ public_platform_wifi_pal
+ PUBLIC_DEPS
+ chre.pal.wifi
+ chre.platform.shared.platform_pal
+ SOURCES
+ platform_wifi.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.platform.platform_wifi.facade
+ chre.platform.shared.pal_system_api
+ chre.util.system
+ chre.variant.config
+)
+
+pw_add_library(chre.platform.shared.platform_wwan_pal STATIC
+ HEADERS
+ public_platform_wwan_pal/chre/target_platform/platform_wwan_base.h
+ PUBLIC_INCLUDES
+ public_platform_wwan_pal
+ PUBLIC_DEPS
+ chre.pal.wwan
+ chre.platform.shared.platform_pal
+ SOURCES
+ platform_wwan.cc
+ PRIVATE_DEPS
+ chre.core
+ chre.platform.log
+ chre.platform.platform_wwan.facade
+ chre.platform.shared.pal_system_api
+ chre.variant.config
+)
diff --git a/platform/shared/backend.cmake b/platform/shared/backend.cmake
new file mode 100644
index 0000000..5d436df
--- /dev/null
+++ b/platform/shared/backend.cmake
@@ -0,0 +1,27 @@
+include_guard(GLOBAL)
+
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+# Backend for chre.platform.shared.authentication.
+pw_add_backend_variable(chre.platform.shared.authentication_BACKEND)
+
+# Backend for chre.platform.shared.bt_snoop_log.
+pw_add_backend_variable(chre.platform.shared.bt_snoop_log_BACKEND)
+
+# Backend for chre.platform.shared.log_buffer_manager.
+pw_add_backend_variable(chre.platform.shared.log_buffer_manager_BACKEND)
+
+# Backend for chre.platform.shared.memory.
+pw_add_backend_variable(chre.platform.shared.memory_BACKEND)
+
+# Backend for chre.platform.shared.nanoapp_loader.
+pw_add_backend_variable(chre.platform.shared.nanoapp_loader_BACKEND)
+
+# Backend for chre.platform.shared.platform_cache_management.
+pw_add_backend_variable(chre.platform.shared.platform_cache_management_BACKEND)
+
+# Backend for chre.platform.shared.platform_pal.
+pw_add_backend_variable(chre.platform.shared.platform_pal_BACKEND)
+
+# Backend for chre.platform.shared.pal_system_api.
+pw_add_backend_variable(chre.platform.shared.pal_system_api_BACKEND)
diff --git a/platform/shared/chre_api_audio.cc b/platform/shared/chre_api_audio.cc
index adad654..5cec25f 100644
--- a/platform/shared/chre_api_audio.cc
+++ b/platform/shared/chre_api_audio.cc
@@ -20,10 +20,6 @@
#include "chre/util/macros.h"
#include "chre/util/system/napp_permissions.h"
-#ifdef CHRE_AUDIO_SUPPORT_ENABLED
-#include "chre/platform/platform_audio.h"
-#endif // CHRE_AUDIO_SUPPORT_ENABLED
-
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
using chre::Nanoapp;
@@ -65,3 +61,11 @@
return false;
#endif // CHRE_AUDIO_SUPPORT_ENABLED
}
+
+DLL_EXPORT bool chreAudioGetStatus(uint32_t handle,
+ struct chreAudioSourceStatus *status) {
+ // TODO(b/174590023): either implement or deprecate this API
+ UNUSED_VAR(handle);
+ UNUSED_VAR(status);
+ return false;
+}
diff --git a/platform/shared/chre_api_ble.cc b/platform/shared/chre_api_ble.cc
index ea40387..5b65ac1 100644
--- a/platform/shared/chre_api_ble.cc
+++ b/platform/shared/chre_api_ble.cc
@@ -22,6 +22,7 @@
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
+using chre::Nanoapp;
using chre::NanoappPermissions;
DLL_EXPORT uint32_t chreBleGetCapabilities() {
@@ -46,7 +47,7 @@
DLL_EXPORT bool chreBleFlushAsync(const void *cookie) {
#ifdef CHRE_BLE_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_BLE) &&
EventLoopManagerSingleton::get()->getBleRequestManager().flushAsync(
nanoapp, cookie);
@@ -60,7 +61,7 @@
chreBleScanMode mode, uint32_t reportDelayMs,
const struct chreBleScanFilterV1_9 *filter, const void *cookie) {
#ifdef CHRE_BLE_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_BLE) &&
EventLoopManagerSingleton::get()
->getBleRequestManager()
@@ -91,7 +92,7 @@
DLL_EXPORT bool chreBleStopScanAsyncV1_9(const void *cookie) {
#ifdef CHRE_BLE_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_BLE) &&
EventLoopManagerSingleton::get()->getBleRequestManager().stopScanAsync(
nanoapp, cookie);
@@ -108,7 +109,7 @@
DLL_EXPORT bool chreBleReadRssiAsync(uint16_t connectionHandle,
const void *cookie) {
#ifdef CHRE_BLE_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_BLE) &&
EventLoopManagerSingleton::get()->getBleRequestManager().readRssiAsync(
nanoapp, connectionHandle, cookie);
@@ -121,7 +122,7 @@
DLL_EXPORT bool chreBleGetScanStatus(struct chreBleScanStatus *status) {
#ifdef CHRE_BLE_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_BLE) &&
EventLoopManagerSingleton::get()->getBleRequestManager().getScanStatus(
status);
diff --git a/platform/shared/chre_api_core.cc b/platform/shared/chre_api_core.cc
index 780308b..3b5d7db 100644
--- a/platform/shared/chre_api_core.cc
+++ b/platform/shared/chre_api_core.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include "chre_api/chre/event.h"
+
#include <cstdarg>
#include <cstdio>
#include <cstring>
@@ -21,19 +23,15 @@
#include "chre/core/event_loop_manager.h"
#include "chre/core/host_comms_manager.h"
#include "chre/core/host_endpoint_manager.h"
-#include "chre/platform/fatal_error.h"
#include "chre/platform/log.h"
#include "chre/util/macros.h"
#include "chre/util/system/napp_permissions.h"
-#include "chre_api/chre/event.h"
-#include "chre_api/chre/re.h"
-using ::chre::EventLoop;
-using ::chre::EventLoopManager;
-using ::chre::EventLoopManagerSingleton;
-using ::chre::handleNanoappAbort;
-using ::chre::HostCommsManager;
-using ::chre::Nanoapp;
+using chre::EventLoop;
+using chre::EventLoopManager;
+using chre::EventLoopManagerSingleton;
+using chre::HostCommsManager;
+using chre::Nanoapp;
namespace {
@@ -80,19 +78,6 @@
} // namespace
-DLL_EXPORT void chreAbort(uint32_t /* abortCode */) {
- Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
-
- // TODO: we should cleanly unload the nanoapp, release all of its resources,
- // and send an abort notification to the host so as to localize the impact to
- // the calling nanoapp
- if (nanoapp == nullptr) {
- FATAL_ERROR("chreAbort called in unknown context");
- } else {
- handleNanoappAbort(*nanoapp);
- }
-}
-
DLL_EXPORT bool chreSendEvent(uint16_t eventType, void *eventData,
chreEventCompleteFunction *freeCallback,
uint32_t targetInstanceId) {
@@ -183,12 +168,12 @@
}
DLL_EXPORT void chreConfigureNanoappInfoEvents(bool enable) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
nanoapp->configureNanoappInfoEvents(enable);
}
DLL_EXPORT void chreConfigureHostSleepStateEvents(bool enable) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
nanoapp->configureHostSleepEvents(enable);
}
@@ -200,19 +185,19 @@
}
DLL_EXPORT void chreConfigureDebugDumpEvent(bool enable) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
nanoapp->configureDebugDumpEvent(enable);
}
DLL_EXPORT bool chreConfigureHostEndpointNotifications(uint16_t hostEndpointId,
bool enable) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->configureHostEndpointNotifications(hostEndpointId, enable);
}
DLL_EXPORT bool chrePublishRpcServices(struct chreNanoappRpcService *services,
size_t numServices) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->publishRpcServices(services, numServices);
}
diff --git a/platform/shared/chre_api_gnss.cc b/platform/shared/chre_api_gnss.cc
index f1f7706..7e46bc2 100644
--- a/platform/shared/chre_api_gnss.cc
+++ b/platform/shared/chre_api_gnss.cc
@@ -24,13 +24,12 @@
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
using chre::Milliseconds;
+using chre::Nanoapp;
using chre::NanoappPermissions;
DLL_EXPORT uint32_t chreGnssGetCapabilities() {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- return chre::EventLoopManagerSingleton::get()
- ->getGnssManager()
- .getCapabilities();
+ return EventLoopManagerSingleton::get()->getGnssManager().getCapabilities();
#else
return CHRE_GNSS_CAPABILITIES_NONE;
#endif // CHRE_GNSS_SUPPORT_ENABLED
@@ -41,9 +40,9 @@
[[maybe_unused]] uint32_t minTimeToNextFixMs,
[[maybe_unused]] const void *cookie) {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_GNSS) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getGnssManager()
.getLocationSession()
.addRequest(nanoapp, Milliseconds(minIntervalMs),
@@ -56,9 +55,9 @@
DLL_EXPORT bool chreGnssLocationSessionStopAsync(
[[maybe_unused]] const void *cookie) {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_GNSS) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getGnssManager()
.getLocationSession()
.removeRequest(nanoapp, cookie);
@@ -70,9 +69,9 @@
DLL_EXPORT bool chreGnssMeasurementSessionStartAsync(
[[maybe_unused]] uint32_t minIntervalMs, [[maybe_unused]] const void *cookie) {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_GNSS) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getGnssManager()
.getMeasurementSession()
.addRequest(nanoapp, Milliseconds(minIntervalMs),
@@ -85,9 +84,9 @@
DLL_EXPORT bool chreGnssMeasurementSessionStopAsync(
[[maybe_unused]] const void *cookie) {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_GNSS) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getGnssManager()
.getMeasurementSession()
.removeRequest(nanoapp, cookie);
@@ -99,9 +98,9 @@
DLL_EXPORT bool chreGnssConfigurePassiveLocationListener(
[[maybe_unused]] bool enable) {
#ifdef CHRE_GNSS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_GNSS) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getGnssManager()
.configurePassiveLocationListener(nanoapp, enable);
#else
diff --git a/platform/shared/chre_api_re.cc b/platform/shared/chre_api_re.cc
index 11102ed..3d7c8fd 100644
--- a/platform/shared/chre_api_re.cc
+++ b/platform/shared/chre_api_re.cc
@@ -14,17 +14,19 @@
* limitations under the License.
*/
+#include "chre_api/chre/re.h"
+
#include "chre/core/event_loop.h"
#include "chre/core/event_loop_manager.h"
-#include "chre/platform/assert.h"
-#include "chre/platform/memory.h"
+#include "chre/platform/fatal_error.h"
#include "chre/platform/shared/debug_dump.h"
#include "chre/platform/system_time.h"
#include "chre/util/macros.h"
-#include "chre_api/chre/re.h"
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
+using chre::handleNanoappAbort;
+using chre::Nanoapp;
DLL_EXPORT uint32_t chreGetCapabilities() {
uint32_t capabilities = CHRE_CAPABILITIES_NONE;
@@ -37,26 +39,27 @@
}
DLL_EXPORT uint32_t chreGetMessageToHostMaxSize() {
-#ifdef CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED
-
-#ifndef CHRE_LARGE_PAYLOAD_MAX_SIZE
- static_assert(false,
- "CHRE_LARGE_PAYLOAD_MAX_SIZE must be defined if "
- "CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED is enabled");
-#else
+#ifdef CHRE_LARGE_PAYLOAD_MAX_SIZE
static_assert(CHRE_LARGE_PAYLOAD_MAX_SIZE >= CHRE_MESSAGE_TO_HOST_MAX_SIZE,
"CHRE_LARGE_PAYLOAD_MAX_SIZE must be greater than or equal to "
"CHRE_MESSAGE_TO_HOST_MAX_SIZE");
+#ifdef CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED
static_assert(CHRE_LARGE_PAYLOAD_MAX_SIZE >= 32000,
"CHRE_LARGE_PAYLOAD_MAX_SIZE must be greater than or equal to "
"32000 when CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED is enabled");
- return CHRE_LARGE_PAYLOAD_MAX_SIZE;
-#endif // CHRE_LARGE_PAYLOAD_MAX_SIZE
+#endif
+ return CHRE_LARGE_PAYLOAD_MAX_SIZE;
#else
+#ifdef CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED
+ static_assert(false,
+ "CHRE_LARGE_PAYLOAD_MAX_SIZE must be defined if "
+ "CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED is enabled");
+#endif
+
return CHRE_MESSAGE_TO_HOST_MAX_SIZE;
-#endif // CHRE_RELIABLE_MESSAGE_SUPPORT_ENABLED
+#endif // CHRE_LARGE_PAYLOAD_MAX_SIZE
}
DLL_EXPORT uint64_t chreGetTime() {
@@ -68,18 +71,18 @@
}
DLL_EXPORT uint64_t chreGetAppId(void) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->getAppId();
}
DLL_EXPORT uint32_t chreGetInstanceId(void) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->getInstanceId();
}
DLL_EXPORT uint32_t chreTimerSet(uint64_t duration, const void *cookie,
bool oneShot) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return EventLoopManagerSingleton::get()
->getEventLoop()
.getTimerPool()
@@ -87,32 +90,39 @@
}
DLL_EXPORT bool chreTimerCancel(uint32_t timerId) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return EventLoopManagerSingleton::get()
->getEventLoop()
.getTimerPool()
.cancelNanoappTimer(nanoapp, timerId);
}
+DLL_EXPORT void chreAbort(uint32_t /* abortCode */) {
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ if (nanoapp == nullptr) {
+ FATAL_ERROR("chreAbort called in unknown context");
+ } else {
+ handleNanoappAbort(*nanoapp);
+ }
+}
+
DLL_EXPORT void *chreHeapAlloc(uint32_t bytes) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
- return chre::EventLoopManagerSingleton::get()
- ->getMemoryManager()
- .nanoappAlloc(nanoapp, bytes);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ return EventLoopManagerSingleton::get()->getMemoryManager().nanoappAlloc(
+ nanoapp, bytes);
}
DLL_EXPORT void chreHeapFree(void *ptr) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
- chre::EventLoopManagerSingleton::get()->getMemoryManager().nanoappFree(
- nanoapp, ptr);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ EventLoopManagerSingleton::get()->getMemoryManager().nanoappFree(nanoapp,
+ ptr);
}
DLL_EXPORT void platform_chreDebugDumpVaLog(const char *formatStr,
va_list args) {
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
- chre::EventLoopManagerSingleton::get()
- ->getDebugDumpManager()
- .appendNanoappLog(*nanoapp, formatStr, args);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ EventLoopManagerSingleton::get()->getDebugDumpManager().appendNanoappLog(
+ *nanoapp, formatStr, args);
}
DLL_EXPORT void chreDebugDumpLog(const char *formatStr, ...) {
diff --git a/platform/shared/chre_api_sensor.cc b/platform/shared/chre_api_sensor.cc
index 9b7b434..6f5b408 100644
--- a/platform/shared/chre_api_sensor.cc
+++ b/platform/shared/chre_api_sensor.cc
@@ -14,15 +14,16 @@
* limitations under the License.
*/
+#include "chre_api/chre/sensor.h"
+
#include "chre/core/event_loop_manager.h"
#include "chre/core/sensor_request.h"
-#include "chre/core/sensor_type_helpers.h"
#include "chre/util/macros.h"
#include "chre/util/time.h"
-#include "chre_api/chre/sensor.h"
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
+using chre::Nanoapp;
using chre::Nanoseconds;
using chre::SensorMode;
using chre::SensorRequest;
@@ -36,7 +37,7 @@
DLL_EXPORT bool chreSensorFind(uint8_t sensorType, uint8_t sensorIndex,
uint32_t *handle) {
#if CHRE_SENSORS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return EventLoopManagerSingleton::get()
->getSensorRequestManager()
.getSensorHandleForNanoapp(sensorType, sensorIndex, *nanoapp, handle);
@@ -53,7 +54,7 @@
#ifdef CHRE_SENSORS_SUPPORT_ENABLED
CHRE_ASSERT(info);
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
bool success = false;
if (info != nullptr) {
@@ -92,7 +93,7 @@
enum chreSensorConfigureMode mode,
uint64_t interval, uint64_t latency) {
#ifdef CHRE_SENSORS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
SensorMode sensorMode = getSensorModeFromEnum(mode);
SensorRequest sensorRequest(nanoapp->getInstanceId(), sensorMode,
Nanoseconds(interval), Nanoseconds(latency));
@@ -111,7 +112,7 @@
DLL_EXPORT bool chreSensorConfigureBiasEvents(uint32_t sensorHandle,
bool enable) {
#ifdef CHRE_SENSORS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return EventLoopManagerSingleton::get()
->getSensorRequestManager()
.configureBiasEvents(nanoapp, sensorHandle, enable);
@@ -138,7 +139,7 @@
DLL_EXPORT bool chreSensorFlushAsync(uint32_t sensorHandle,
const void *cookie) {
#ifdef CHRE_SENSORS_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return EventLoopManagerSingleton::get()->getSensorRequestManager().flushAsync(
nanoapp, sensorHandle, cookie);
#else // CHRE_SENSORS_SUPPORT_ENABLED
diff --git a/platform/shared/chre_api_user_settings.cc b/platform/shared/chre_api_user_settings.cc
index 8ebba49..79394e7 100644
--- a/platform/shared/chre_api_user_settings.cc
+++ b/platform/shared/chre_api_user_settings.cc
@@ -21,11 +21,12 @@
#include "chre/util/macros.h"
using chre::EventLoopManager;
+using chre::EventLoopManagerSingleton;
using chre::Nanoapp;
using chre::Setting;
DLL_EXPORT int8_t chreUserSettingGetState(uint8_t setting) {
- return chre::EventLoopManagerSingleton::get()
+ return EventLoopManagerSingleton::get()
->getSettingManager()
.getSettingStateAsInt8(setting);
}
diff --git a/platform/shared/chre_api_wifi.cc b/platform/shared/chre_api_wifi.cc
index 02b3785..8617100 100644
--- a/platform/shared/chre_api_wifi.cc
+++ b/platform/shared/chre_api_wifi.cc
@@ -22,11 +22,12 @@
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
+using chre::Nanoapp;
using chre::NanoappPermissions;
DLL_EXPORT uint32_t chreWifiGetCapabilities() {
#ifdef CHRE_WIFI_SUPPORT_ENABLED
- return chre::EventLoopManagerSingleton::get()
+ return EventLoopManagerSingleton::get()
->getWifiRequestManager()
.getCapabilities();
#else
@@ -37,7 +38,7 @@
DLL_EXPORT bool chreWifiConfigureScanMonitorAsync(
[[maybe_unused]] bool enable, [[maybe_unused]] const void *cookie) {
#ifdef CHRE_WIFI_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()
->getWifiRequestManager()
@@ -51,7 +52,7 @@
[[maybe_unused]] const struct chreWifiScanParams *params,
[[maybe_unused]] const void *cookie) {
#ifdef CHRE_WIFI_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()->getWifiRequestManager().requestScan(
nanoapp, params, cookie);
@@ -64,7 +65,7 @@
[[maybe_unused]] const struct chreWifiRangingParams *params,
[[maybe_unused]] const void *cookie) {
#ifdef CHRE_WIFI_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()
->getWifiRequestManager()
@@ -79,7 +80,7 @@
[[maybe_unused]] struct chreWifiNanSubscribeConfig *config,
[[maybe_unused]] const void *cookie) {
#if defined(CHRE_WIFI_SUPPORT_ENABLED) && defined(CHRE_WIFI_NAN_SUPPORT_ENABLED)
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()->getWifiRequestManager().nanSubscribe(
nanoapp, config, cookie);
@@ -91,7 +92,7 @@
DLL_EXPORT bool chreWifiNanSubscribeCancel(
[[maybe_unused]] uint32_t subscriptionId) {
#if defined(CHRE_WIFI_SUPPORT_ENABLED) && defined(CHRE_WIFI_NAN_SUPPORT_ENABLED)
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()
->getWifiRequestManager()
@@ -105,7 +106,7 @@
[[maybe_unused]] const struct chreWifiNanRangingParams *params,
[[maybe_unused]] const void *cookie) {
#if defined(CHRE_WIFI_SUPPORT_ENABLED) && defined(CHRE_WIFI_NAN_SUPPORT_ENABLED)
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WIFI) &&
EventLoopManagerSingleton::get()
->getWifiRequestManager()
diff --git a/platform/shared/chre_api_wwan.cc b/platform/shared/chre_api_wwan.cc
index aa47722..b7bb634 100644
--- a/platform/shared/chre_api_wwan.cc
+++ b/platform/shared/chre_api_wwan.cc
@@ -22,11 +22,12 @@
using chre::EventLoopManager;
using chre::EventLoopManagerSingleton;
+using chre::Nanoapp;
using chre::NanoappPermissions;
DLL_EXPORT uint32_t chreWwanGetCapabilities() {
#ifdef CHRE_WWAN_SUPPORT_ENABLED
- return chre::EventLoopManagerSingleton::get()
+ return EventLoopManagerSingleton::get()
->getWwanRequestManager()
.getCapabilities();
#else
@@ -36,9 +37,9 @@
DLL_EXPORT bool chreWwanGetCellInfoAsync([[maybe_unused]] const void *cookie) {
#ifdef CHRE_WWAN_SUPPORT_ENABLED
- chre::Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
+ Nanoapp *nanoapp = EventLoopManager::validateChreApiCall(__func__);
return nanoapp->permitPermissionUse(NanoappPermissions::CHRE_PERMS_WWAN) &&
- chre::EventLoopManagerSingleton::get()
+ EventLoopManagerSingleton::get()
->getWwanRequestManager()
.requestCellInfo(nanoapp, cookie);
#else
diff --git a/platform/shared/dlfcn.cc b/platform/shared/dlfcn.cc
index 630b73c..d561676 100644
--- a/platform/shared/dlfcn.cc
+++ b/platform/shared/dlfcn.cc
@@ -17,6 +17,7 @@
#include <dlfcn.h>
#include "chre/platform/assert.h"
+#include "chre/platform/log.h"
#include "chre/platform/shared/nanoapp_loader.h"
#include "chre/util/unique_ptr.h"
diff --git a/platform/shared/host_link.cc b/platform/shared/host_link.cc
index 7a0c797..2eff593 100644
--- a/platform/shared/host_link.cc
+++ b/platform/shared/host_link.cc
@@ -73,8 +73,13 @@
if (getLoadManager().hasPendingLoadTransaction()) {
FragmentedLoadInfo info = getLoadManager().getTransactionInfo();
+ LOGW("A pending load transaction already exists (clientId=%" PRIu16
+ ", txnId=%" PRIu32 ", nextFragmentId=%" PRIu32 "). Overriding it",
+ info.hostClientId, info.transactionId, info.nextFragmentId);
+ // Send a failure response to host where nextFragmentId is either current
+ // or future to the host.
sendFragmentResponse(info.hostClientId, info.transactionId,
- 0 /* fragmentId */, false /* success */);
+ info.nextFragmentId, /* success= */ false);
getLoadManager().markFailure();
}
diff --git a/platform/shared/host_protocol_chre.cc b/platform/shared/host_protocol_chre.cc
index ca0c86b..6224135 100644
--- a/platform/shared/host_protocol_chre.cc
+++ b/platform/shared/host_protocol_chre.cc
@@ -18,6 +18,7 @@
#include <inttypes.h>
#include <string.h>
+#include <cstdint>
#include "chre/core/event_loop_manager.h"
#include "chre/core/host_endpoint_manager.h"
@@ -200,13 +201,53 @@
break;
}
+ case fbs::ChreMessage::BtSocketOpen: {
+ const auto *btSocketOpen =
+ static_cast<const fbs::BtSocketOpen *>(container->message());
+ if (btSocketOpen->channelInfo_type() !=
+ fbs::ChannelInfo::LeCocChannelInfo) {
+ LOGW("Unexpected BT Socket Open Channel Info Type %" PRIu8,
+ static_cast<uint8_t>(btSocketOpen->channelInfo_type()));
+ } else {
+ const auto *leCocChannelInfo =
+ static_cast<const fbs::LeCocChannelInfo *>(
+ btSocketOpen->channelInfo());
+ const char *name = getStringFromByteVector(btSocketOpen->name());
+ HostMessageHandlers::handleBtSocketOpen(
+ hostClientId, static_cast<uint64_t>(btSocketOpen->socketId()),
+ name, static_cast<uint64_t>(btSocketOpen->endpointId()),
+ static_cast<uint64_t>(btSocketOpen->hubId()),
+ static_cast<uint32_t>(btSocketOpen->aclConnectionHandle()),
+ static_cast<uint32_t>(leCocChannelInfo->localCid()),
+ static_cast<uint32_t>(leCocChannelInfo->remoteCid()),
+ static_cast<uint32_t>(leCocChannelInfo->psm()),
+ static_cast<uint32_t>(leCocChannelInfo->localMtu()),
+ static_cast<uint32_t>(leCocChannelInfo->remoteMtu()),
+ static_cast<uint32_t>(leCocChannelInfo->localMps()),
+ static_cast<uint32_t>(leCocChannelInfo->remoteMps()),
+ static_cast<uint32_t>(leCocChannelInfo->initialRxCredits()),
+ static_cast<uint32_t>(leCocChannelInfo->initialTxCredits()));
+ success = true;
+ }
+ break;
+ }
+
+ case fbs::ChreMessage::BtSocketCloseResponse: {
+ const auto *btSocketCloseResponse =
+ static_cast<const fbs::BtSocketCloseResponse *>(
+ container->message());
+ LOGD("Received BT Socket close response for socketId=%" PRIu64,
+ btSocketCloseResponse->socketId());
+ success = true;
+ break;
+ }
+
default:
LOGW("Got invalid/unexpected message type %" PRIu8,
static_cast<uint8_t>(container->message_type()));
success = false;
}
}
-
return success;
}
@@ -383,6 +424,29 @@
finalize(builder, fbs::ChreMessage::NanConfigurationRequest, request.Union());
}
+void HostProtocolChre::encodeBtSocketOpenResponse(
+ ChreFlatBufferBuilder &builder, uint16_t hostClientId, uint64_t socketId,
+ bool success, const char *reason) {
+ auto reasonOffset = addStringAsByteVector(builder, reason);
+ auto socketOpenResponse = fbs::CreateBtSocketOpenResponse(
+ builder, socketId,
+ success ? fbs::BtSocketOpenStatus::SUCCESS
+ : fbs::BtSocketOpenStatus::FAILURE,
+ reasonOffset);
+ finalize(builder, fbs::ChreMessage::BtSocketOpenResponse,
+ socketOpenResponse.Union(), hostClientId);
+}
+
+void HostProtocolChre::encodeBtSocketClose(ChreFlatBufferBuilder &builder,
+ uint16_t hostClientId,
+ uint64_t socketId,
+ const char *reason) {
+ auto reasonOffset = addStringAsByteVector(builder, reason);
+ auto socketClose = fbs::CreateBtSocketClose(builder, socketId, reasonOffset);
+ finalize(builder, fbs::ChreMessage::BtSocketClose, socketClose.Union(),
+ hostClientId);
+}
+
bool HostProtocolChre::getSettingFromFbs(fbs::Setting setting,
Setting *chreSetting) {
bool success = true;
diff --git a/platform/shared/idl/host_messages.fbs b/platform/shared/idl/host_messages.fbs
index cabc3df..2b86db5 100644
--- a/platform/shared/idl/host_messages.fbs
+++ b/platform/shared/idl/host_messages.fbs
@@ -484,6 +484,281 @@
table PulseRequest {}
table PulseResponse {}
+// LE L2CAP COC channel information.
+table LeCocChannelInfo {
+ // Local Channel Identifier.
+ localCid:int;
+
+ // Remote Channel Identifier.
+ remoteCid:int;
+
+ // Protocol Service Multiplexer.
+ psm:int;
+
+ // Maximum Transmission Unit (MTU, max Rx SDU size) that the local device
+ // will accept for packets received on this channel.
+ localMtu:int;
+
+ // Maximum Transmission Unit (MTU, max Tx SDU size) that the remote device
+ // will accept for packets sent on this channel.
+ remoteMtu:int;
+
+ // Maximum PDU Payload Size (MPS) that the local device will accept for
+ // packets received on this channel.
+ localMps:int;
+
+ // Maximum PDU Payload Size (MPS) that the remote device will accept for
+ // packets sent on this channel.
+ remoteMps:int;
+
+ // The amount of PDUs that the local device will accept from this channel.
+ initialRxCredits:int;
+
+ // The amount of PDUs that the remote device will accept from this channel.
+ initialTxCredits:int;
+}
+
+// Used to specify the channel information of different protocol.
+union ChannelInfo {
+ LeCocChannelInfo
+}
+
+// Request from the host to the offload domain to open a BT socket.
+table BtSocketOpen {
+ // Unique identifier for this socket connection. This ID in the offload
+ // domain matches the ID used on the host side. It is valid only while the
+ // socket is connected.
+ socketId:long;
+
+ // The name of the socket. Nominally a UTF-8 string, but note that we're not
+ // using the built-in "string" data type from FlatBuffers here, because the
+ // generated C++ uses std::string which is not well-supported in the offload
+ // domain. This applies for vendor and toolchain as well.
+ name:[byte];
+
+ // ACL connection handle for the socket.
+ aclConnectionHandle:int;
+
+ // Channel information of the socket protocol.
+ channelInfo:ChannelInfo;
+
+ // The ID of the Hub to which the end point belongs for hardware offload
+ // data path.
+ hubId:long;
+
+ // The ID of the Hub endpoint for hardware offload data path.
+ endpointId:long;
+}
+
+// Status of BT socket open request.
+enum BtSocketOpenStatus : byte {
+ SUCCESS = 0,
+ FAILURE,
+}
+
+// Callback from the offload domain to the host to acknowledge that a BT socket
+// has been opened successfully or has failed to be opened.
+table BtSocketOpenResponse {
+ // Unique identifier for this socket connection.
+ socketId:long;
+
+ // Status indicating success or failure.
+ status:BtSocketOpenStatus;
+
+ // Reason string of the operation failure for debugging purposes.
+ reason:[byte];
+}
+
+// Request from offload domain to host to close a BT socket.
+table BtSocketClose {
+ // Unique identifier for this socket connection.
+ socketId:long;
+
+ // Reason string for closing the socket for debugging purposes
+ reason:[byte];
+}
+
+// Host callback to acknowledge that a BT socket has been closed.
+table BtSocketCloseResponse {
+ // Unique identifier for this socket connection.
+ socketId:long;
+}
+
+table VendorHubInfo {
+ /// The name of the hub. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ name:[byte];
+
+ /// Hub version
+ version:uint;
+
+ /// Additional vendor-defined data
+ extended_info:[ubyte];
+}
+
+union MessageHubDetails {
+ HubInfoResponse,
+ VendorHubInfo,
+}
+
+table MessageHub {
+ /// The hub id. -1 is reserved and 0 is invalid. 0x416e64726f696400 represents
+ /// the ContextHub service.
+ id:long;
+
+ /// Details of the message hub.
+ details:MessageHubDetails;
+}
+
+table RegisterMessageHub {
+ hub:MessageHub;
+}
+
+table UnregisterMessageHub {
+ id:long;
+}
+
+table EndpointId {
+ /// Id of the hub hosting the endpoint
+ hubId:long;
+
+ /// The id of the endpoint scoped to the hub
+ id:long;
+}
+
+/// An enum describing the type of an endpoint.
+enum EndpointType : ubyte {
+ INVALID = 0,
+ /// The endpoint is part of the Android Framework
+ FRAMEWORK = 1,
+ /// The endpoint is an Android app
+ APP,
+ /// The endpoint is a native Android program
+ NATIVE,
+ /// The endpoint is a nanoapp
+ NANOAPP,
+ /// A generic, non-nanoapp endpoint
+ GENERIC,
+}
+
+enum RpcFormat : ubyte {
+ /// Fully custom format
+ CUSTOM = 0,
+ /// Stable AIDL defined interface using Binder marshalling
+ AIDL,
+ /// Pigweed RPC defined interface using Protobuf marshalling
+ PW_RPC,
+}
+
+table Service {
+ format:RpcFormat;
+
+ /// Service descriptor. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ descriptor:[byte];
+
+ /// Breaking changes should bump the major version.
+ major_version:uint;
+ /// Monotonically increasing minor version.
+ minor_version:uint;
+}
+
+table EndpointInfo {
+ id:EndpointId;
+ type:EndpointType;
+
+ /// Endpoing name. Nominally a UTF-8 string, but note that we're not using
+ /// the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ name:[byte];
+ version:uint;
+
+ /// Values from CHRE_MESSAGE_PERMISSION_*
+ required_permissions:uint;
+ services:[Service];
+}
+
+table RegisterEndpoint {
+ endpoint:EndpointInfo;
+}
+
+table UnregisterEndpoint {
+ endpoint:EndpointId;
+}
+
+/// HAL->CHRE, indicates the HAL is coming up
+table GetMessageHubsAndEndpointsRequest {}
+table GetMessageHubsAndEndpointsResponse {
+ hubs:[MessageHub];
+ endpoints:[EndpointInfo];
+}
+
+table OpenEndpointSessionRequest {
+ id:ushort;
+ fromEndpoint:EndpointId;
+ toEndpoint:EndpointId;
+
+ /// If present, describes the service definition used over the session
+ serviceDescriptor:[byte];
+}
+
+table EndpointSessionOpened {
+ id:ushort;
+}
+
+/// "Reason"s for stopping an endpoint or session over an endpoint.
+enum Reason : ubyte {
+ /// Unspecified reason.
+ UNSPECIFIED = 0,
+ /// Out of memory. There's not enough memory to perform this operation.
+ OUT_OF_MEMORY,
+ /// Timeout. This operation timed out.
+ TIMEOUT,
+ /// Endpoint rejected this openEndpointSession request.
+ OPEN_ENDPOINT_SESSION_REQUEST_REJECTED,
+ /// Endpoint requested closeEndpointSession.
+ CLOSE_ENDPOINT_SESSION_REQUESTED,
+ /// Invalid endpoint.
+ ENDPOINT_INVALID,
+ /// Endpoint is now stopped.
+ ENDPOINT_GONE,
+ /// Endpoint crashed.
+ ENDPOINT_CRASHED,
+ /// Hub was reset or is resetting.
+ HUB_RESET,
+}
+
+table EndpointSessionClosed {
+ id:ushort;
+ reason:Reason;
+}
+
+table EndpointSessionMessage {
+ /// Id of session this message is being sent within
+ session_id:ushort;
+
+ /// Type of the message, specific to the Session protocol
+ type:uint;
+
+ /// Values from CHRE_MESSAGE_PERMISSION_*. Permissions required to read the
+ /// message.
+ permissions:uint;
+ data:[ubyte];
+
+ /// Bitmask of additional flags applied to the message:
+ /// - 0x1: Message delivery status required within 1s
+ flags:uint;
+ sequence_number:uint;
+}
+
+table EndpointSessionMessageDeliveryStatus {
+ /// Id of session the message was sent within
+ session_id:ushort;
+ status:MessageDeliveryStatus;
+}
+
/// A union that joins together all possible messages. Note that in FlatBuffers,
/// unions have an implicit type
union ChreMessage {
@@ -538,6 +813,27 @@
NanoappTokenDatabaseInfo,
MessageDeliveryStatus,
+
+ BtSocketOpen,
+ BtSocketOpenResponse,
+ BtSocketClose,
+ BtSocketCloseResponse,
+
+ GetMessageHubsAndEndpointsRequest,
+ GetMessageHubsAndEndpointsResponse,
+
+ RegisterMessageHub,
+ UnregisterMessageHub,
+
+ RegisterEndpoint,
+ UnregisterEndpoint,
+
+ OpenEndpointSessionRequest,
+ EndpointSessionOpened,
+ EndpointSessionClosed,
+
+ EndpointSessionMessage,
+ EndpointSessionMessageDeliveryStatus,
}
struct HostAddress {
diff --git a/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h b/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
index 86c6cbc..4101439 100644
--- a/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
+++ b/platform/shared/include/chre/platform/shared/generated/host_messages_generated.h
@@ -111,6 +111,69 @@
struct PulseResponse;
struct PulseResponseBuilder;
+struct LeCocChannelInfo;
+struct LeCocChannelInfoBuilder;
+
+struct BtSocketOpen;
+struct BtSocketOpenBuilder;
+
+struct BtSocketOpenResponse;
+struct BtSocketOpenResponseBuilder;
+
+struct BtSocketClose;
+struct BtSocketCloseBuilder;
+
+struct BtSocketCloseResponse;
+struct BtSocketCloseResponseBuilder;
+
+struct VendorHubInfo;
+struct VendorHubInfoBuilder;
+
+struct MessageHub;
+struct MessageHubBuilder;
+
+struct RegisterMessageHub;
+struct RegisterMessageHubBuilder;
+
+struct UnregisterMessageHub;
+struct UnregisterMessageHubBuilder;
+
+struct EndpointId;
+struct EndpointIdBuilder;
+
+struct Service;
+struct ServiceBuilder;
+
+struct EndpointInfo;
+struct EndpointInfoBuilder;
+
+struct RegisterEndpoint;
+struct RegisterEndpointBuilder;
+
+struct UnregisterEndpoint;
+struct UnregisterEndpointBuilder;
+
+struct GetMessageHubsAndEndpointsRequest;
+struct GetMessageHubsAndEndpointsRequestBuilder;
+
+struct GetMessageHubsAndEndpointsResponse;
+struct GetMessageHubsAndEndpointsResponseBuilder;
+
+struct OpenEndpointSessionRequest;
+struct OpenEndpointSessionRequestBuilder;
+
+struct EndpointSessionOpened;
+struct EndpointSessionOpenedBuilder;
+
+struct EndpointSessionClosed;
+struct EndpointSessionClosedBuilder;
+
+struct EndpointSessionMessage;
+struct EndpointSessionMessageBuilder;
+
+struct EndpointSessionMessageDeliveryStatus;
+struct EndpointSessionMessageDeliveryStatusBuilder;
+
struct HostAddress;
struct MessageContainer;
@@ -292,6 +355,270 @@
return EnumNamesBtSnoopDirection()[index];
}
+enum class ChannelInfo : uint8_t {
+ NONE = 0,
+ LeCocChannelInfo = 1,
+ MIN = NONE,
+ MAX = LeCocChannelInfo
+};
+
+inline const ChannelInfo (&EnumValuesChannelInfo())[2] {
+ static const ChannelInfo values[] = {
+ ChannelInfo::NONE,
+ ChannelInfo::LeCocChannelInfo
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesChannelInfo() {
+ static const char * const names[3] = {
+ "NONE",
+ "LeCocChannelInfo",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameChannelInfo(ChannelInfo e) {
+ if (flatbuffers::IsOutRange(e, ChannelInfo::NONE, ChannelInfo::LeCocChannelInfo)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesChannelInfo()[index];
+}
+
+template<typename T> struct ChannelInfoTraits {
+ static const ChannelInfo enum_value = ChannelInfo::NONE;
+};
+
+template<> struct ChannelInfoTraits<chre::fbs::LeCocChannelInfo> {
+ static const ChannelInfo enum_value = ChannelInfo::LeCocChannelInfo;
+};
+
+bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type);
+bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+enum class BtSocketOpenStatus : int8_t {
+ SUCCESS = 0,
+ FAILURE = 1,
+ MIN = SUCCESS,
+ MAX = FAILURE
+};
+
+inline const BtSocketOpenStatus (&EnumValuesBtSocketOpenStatus())[2] {
+ static const BtSocketOpenStatus values[] = {
+ BtSocketOpenStatus::SUCCESS,
+ BtSocketOpenStatus::FAILURE
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesBtSocketOpenStatus() {
+ static const char * const names[3] = {
+ "SUCCESS",
+ "FAILURE",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameBtSocketOpenStatus(BtSocketOpenStatus e) {
+ if (flatbuffers::IsOutRange(e, BtSocketOpenStatus::SUCCESS, BtSocketOpenStatus::FAILURE)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesBtSocketOpenStatus()[index];
+}
+
+enum class MessageHubDetails : uint8_t {
+ NONE = 0,
+ HubInfoResponse = 1,
+ VendorHubInfo = 2,
+ MIN = NONE,
+ MAX = VendorHubInfo
+};
+
+inline const MessageHubDetails (&EnumValuesMessageHubDetails())[3] {
+ static const MessageHubDetails values[] = {
+ MessageHubDetails::NONE,
+ MessageHubDetails::HubInfoResponse,
+ MessageHubDetails::VendorHubInfo
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesMessageHubDetails() {
+ static const char * const names[4] = {
+ "NONE",
+ "HubInfoResponse",
+ "VendorHubInfo",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameMessageHubDetails(MessageHubDetails e) {
+ if (flatbuffers::IsOutRange(e, MessageHubDetails::NONE, MessageHubDetails::VendorHubInfo)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesMessageHubDetails()[index];
+}
+
+template<typename T> struct MessageHubDetailsTraits {
+ static const MessageHubDetails enum_value = MessageHubDetails::NONE;
+};
+
+template<> struct MessageHubDetailsTraits<chre::fbs::HubInfoResponse> {
+ static const MessageHubDetails enum_value = MessageHubDetails::HubInfoResponse;
+};
+
+template<> struct MessageHubDetailsTraits<chre::fbs::VendorHubInfo> {
+ static const MessageHubDetails enum_value = MessageHubDetails::VendorHubInfo;
+};
+
+bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type);
+bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// An enum describing the type of an endpoint.
+enum class EndpointType : uint8_t {
+ INVALID = 0,
+ /// The endpoint is part of the Android Framework
+ FRAMEWORK = 1,
+ /// The endpoint is an Android app
+ APP = 2,
+ /// The endpoint is a native Android program
+ NATIVE = 3,
+ /// The endpoint is a nanoapp
+ NANOAPP = 4,
+ /// A generic, non-nanoapp endpoint
+ GENERIC = 5,
+ MIN = INVALID,
+ MAX = GENERIC
+};
+
+inline const EndpointType (&EnumValuesEndpointType())[6] {
+ static const EndpointType values[] = {
+ EndpointType::INVALID,
+ EndpointType::FRAMEWORK,
+ EndpointType::APP,
+ EndpointType::NATIVE,
+ EndpointType::NANOAPP,
+ EndpointType::GENERIC
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesEndpointType() {
+ static const char * const names[7] = {
+ "INVALID",
+ "FRAMEWORK",
+ "APP",
+ "NATIVE",
+ "NANOAPP",
+ "GENERIC",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameEndpointType(EndpointType e) {
+ if (flatbuffers::IsOutRange(e, EndpointType::INVALID, EndpointType::GENERIC)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesEndpointType()[index];
+}
+
+enum class RpcFormat : uint8_t {
+ /// Fully custom format
+ CUSTOM = 0,
+ /// Stable AIDL defined interface using Binder marshalling
+ AIDL = 1,
+ /// Pigweed RPC defined interface using Protobuf marshalling
+ PW_RPC = 2,
+ MIN = CUSTOM,
+ MAX = PW_RPC
+};
+
+inline const RpcFormat (&EnumValuesRpcFormat())[3] {
+ static const RpcFormat values[] = {
+ RpcFormat::CUSTOM,
+ RpcFormat::AIDL,
+ RpcFormat::PW_RPC
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesRpcFormat() {
+ static const char * const names[4] = {
+ "CUSTOM",
+ "AIDL",
+ "PW_RPC",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameRpcFormat(RpcFormat e) {
+ if (flatbuffers::IsOutRange(e, RpcFormat::CUSTOM, RpcFormat::PW_RPC)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesRpcFormat()[index];
+}
+
+/// "Reason"s for stopping an endpoint or session over an endpoint.
+enum class Reason : uint8_t {
+ /// Unspecified reason.
+ UNSPECIFIED = 0,
+ /// Out of memory. There's not enough memory to perform this operation.
+ OUT_OF_MEMORY = 1,
+ /// Timeout. This operation timed out.
+ TIMEOUT = 2,
+ /// Endpoint rejected this openEndpointSession request.
+ OPEN_ENDPOINT_SESSION_REQUEST_REJECTED = 3,
+ /// Endpoint requested closeEndpointSession.
+ CLOSE_ENDPOINT_SESSION_REQUESTED = 4,
+ /// Invalid endpoint.
+ ENDPOINT_INVALID = 5,
+ /// Endpoint is now stopped.
+ ENDPOINT_GONE = 6,
+ /// Endpoint crashed.
+ ENDPOINT_CRASHED = 7,
+ /// Hub was reset or is resetting.
+ HUB_RESET = 8,
+ MIN = UNSPECIFIED,
+ MAX = HUB_RESET
+};
+
+inline const Reason (&EnumValuesReason())[9] {
+ static const Reason values[] = {
+ Reason::UNSPECIFIED,
+ Reason::OUT_OF_MEMORY,
+ Reason::TIMEOUT,
+ Reason::OPEN_ENDPOINT_SESSION_REQUEST_REJECTED,
+ Reason::CLOSE_ENDPOINT_SESSION_REQUESTED,
+ Reason::ENDPOINT_INVALID,
+ Reason::ENDPOINT_GONE,
+ Reason::ENDPOINT_CRASHED,
+ Reason::HUB_RESET
+ };
+ return values;
+}
+
+inline const char * const *EnumNamesReason() {
+ static const char * const names[10] = {
+ "UNSPECIFIED",
+ "OUT_OF_MEMORY",
+ "TIMEOUT",
+ "OPEN_ENDPOINT_SESSION_REQUEST_REJECTED",
+ "CLOSE_ENDPOINT_SESSION_REQUESTED",
+ "ENDPOINT_INVALID",
+ "ENDPOINT_GONE",
+ "ENDPOINT_CRASHED",
+ "HUB_RESET",
+ nullptr
+ };
+ return names;
+}
+
+inline const char *EnumNameReason(Reason e) {
+ if (flatbuffers::IsOutRange(e, Reason::UNSPECIFIED, Reason::HUB_RESET)) return "";
+ const size_t index = static_cast<size_t>(e);
+ return EnumNamesReason()[index];
+}
+
/// A union that joins together all possible messages. Note that in FlatBuffers,
/// unions have an implicit type
enum class ChreMessage : uint8_t {
@@ -328,11 +655,26 @@
PulseResponse = 30,
NanoappTokenDatabaseInfo = 31,
MessageDeliveryStatus = 32,
+ BtSocketOpen = 33,
+ BtSocketOpenResponse = 34,
+ BtSocketClose = 35,
+ BtSocketCloseResponse = 36,
+ GetMessageHubsAndEndpointsRequest = 37,
+ GetMessageHubsAndEndpointsResponse = 38,
+ RegisterMessageHub = 39,
+ UnregisterMessageHub = 40,
+ RegisterEndpoint = 41,
+ UnregisterEndpoint = 42,
+ OpenEndpointSessionRequest = 43,
+ EndpointSessionOpened = 44,
+ EndpointSessionClosed = 45,
+ EndpointSessionMessage = 46,
+ EndpointSessionMessageDeliveryStatus = 47,
MIN = NONE,
- MAX = MessageDeliveryStatus
+ MAX = EndpointSessionMessageDeliveryStatus
};
-inline const ChreMessage (&EnumValuesChreMessage())[33] {
+inline const ChreMessage (&EnumValuesChreMessage())[48] {
static const ChreMessage values[] = {
ChreMessage::NONE,
ChreMessage::NanoappMessage,
@@ -366,13 +708,28 @@
ChreMessage::PulseRequest,
ChreMessage::PulseResponse,
ChreMessage::NanoappTokenDatabaseInfo,
- ChreMessage::MessageDeliveryStatus
+ ChreMessage::MessageDeliveryStatus,
+ ChreMessage::BtSocketOpen,
+ ChreMessage::BtSocketOpenResponse,
+ ChreMessage::BtSocketClose,
+ ChreMessage::BtSocketCloseResponse,
+ ChreMessage::GetMessageHubsAndEndpointsRequest,
+ ChreMessage::GetMessageHubsAndEndpointsResponse,
+ ChreMessage::RegisterMessageHub,
+ ChreMessage::UnregisterMessageHub,
+ ChreMessage::RegisterEndpoint,
+ ChreMessage::UnregisterEndpoint,
+ ChreMessage::OpenEndpointSessionRequest,
+ ChreMessage::EndpointSessionOpened,
+ ChreMessage::EndpointSessionClosed,
+ ChreMessage::EndpointSessionMessage,
+ ChreMessage::EndpointSessionMessageDeliveryStatus
};
return values;
}
inline const char * const *EnumNamesChreMessage() {
- static const char * const names[34] = {
+ static const char * const names[49] = {
"NONE",
"NanoappMessage",
"HubInfoRequest",
@@ -406,13 +763,28 @@
"PulseResponse",
"NanoappTokenDatabaseInfo",
"MessageDeliveryStatus",
+ "BtSocketOpen",
+ "BtSocketOpenResponse",
+ "BtSocketClose",
+ "BtSocketCloseResponse",
+ "GetMessageHubsAndEndpointsRequest",
+ "GetMessageHubsAndEndpointsResponse",
+ "RegisterMessageHub",
+ "UnregisterMessageHub",
+ "RegisterEndpoint",
+ "UnregisterEndpoint",
+ "OpenEndpointSessionRequest",
+ "EndpointSessionOpened",
+ "EndpointSessionClosed",
+ "EndpointSessionMessage",
+ "EndpointSessionMessageDeliveryStatus",
nullptr
};
return names;
}
inline const char *EnumNameChreMessage(ChreMessage e) {
- if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::MessageDeliveryStatus)) return "";
+ if (flatbuffers::IsOutRange(e, ChreMessage::NONE, ChreMessage::EndpointSessionMessageDeliveryStatus)) return "";
const size_t index = static_cast<size_t>(e);
return EnumNamesChreMessage()[index];
}
@@ -549,6 +921,66 @@
static const ChreMessage enum_value = ChreMessage::MessageDeliveryStatus;
};
+template<> struct ChreMessageTraits<chre::fbs::BtSocketOpen> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketOpen;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketOpenResponse> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketOpenResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketClose> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketClose;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::BtSocketCloseResponse> {
+ static const ChreMessage enum_value = ChreMessage::BtSocketCloseResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsRequest> {
+ static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsRequest;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::GetMessageHubsAndEndpointsResponse> {
+ static const ChreMessage enum_value = ChreMessage::GetMessageHubsAndEndpointsResponse;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::RegisterMessageHub> {
+ static const ChreMessage enum_value = ChreMessage::RegisterMessageHub;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::UnregisterMessageHub> {
+ static const ChreMessage enum_value = ChreMessage::UnregisterMessageHub;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::RegisterEndpoint> {
+ static const ChreMessage enum_value = ChreMessage::RegisterEndpoint;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::UnregisterEndpoint> {
+ static const ChreMessage enum_value = ChreMessage::UnregisterEndpoint;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::OpenEndpointSessionRequest> {
+ static const ChreMessage enum_value = ChreMessage::OpenEndpointSessionRequest;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionOpened> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionOpened;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionClosed> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionClosed;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessage> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionMessage;
+};
+
+template<> struct ChreMessageTraits<chre::fbs::EndpointSessionMessageDeliveryStatus> {
+ static const ChreMessage enum_value = ChreMessage::EndpointSessionMessageDeliveryStatus;
+};
+
bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
@@ -2787,6 +3219,1501 @@
return builder_.Finish();
}
+struct LeCocChannelInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef LeCocChannelInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_LOCALCID = 4,
+ VT_REMOTECID = 6,
+ VT_PSM = 8,
+ VT_LOCALMTU = 10,
+ VT_REMOTEMTU = 12,
+ VT_LOCALMPS = 14,
+ VT_REMOTEMPS = 16,
+ VT_INITIALRXCREDITS = 18,
+ VT_INITIALTXCREDITS = 20
+ };
+ int32_t localCid() const {
+ return GetField<int32_t>(VT_LOCALCID, 0);
+ }
+ int32_t remoteCid() const {
+ return GetField<int32_t>(VT_REMOTECID, 0);
+ }
+ int32_t psm() const {
+ return GetField<int32_t>(VT_PSM, 0);
+ }
+ int32_t localMtu() const {
+ return GetField<int32_t>(VT_LOCALMTU, 0);
+ }
+ int32_t remoteMtu() const {
+ return GetField<int32_t>(VT_REMOTEMTU, 0);
+ }
+ int32_t localMps() const {
+ return GetField<int32_t>(VT_LOCALMPS, 0);
+ }
+ int32_t remoteMps() const {
+ return GetField<int32_t>(VT_REMOTEMPS, 0);
+ }
+ int32_t initialRxCredits() const {
+ return GetField<int32_t>(VT_INITIALRXCREDITS, 0);
+ }
+ int32_t initialTxCredits() const {
+ return GetField<int32_t>(VT_INITIALTXCREDITS, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int32_t>(verifier, VT_LOCALCID) &&
+ VerifyField<int32_t>(verifier, VT_REMOTECID) &&
+ VerifyField<int32_t>(verifier, VT_PSM) &&
+ VerifyField<int32_t>(verifier, VT_LOCALMTU) &&
+ VerifyField<int32_t>(verifier, VT_REMOTEMTU) &&
+ VerifyField<int32_t>(verifier, VT_LOCALMPS) &&
+ VerifyField<int32_t>(verifier, VT_REMOTEMPS) &&
+ VerifyField<int32_t>(verifier, VT_INITIALRXCREDITS) &&
+ VerifyField<int32_t>(verifier, VT_INITIALTXCREDITS) &&
+ verifier.EndTable();
+ }
+};
+
+struct LeCocChannelInfoBuilder {
+ typedef LeCocChannelInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_localCid(int32_t localCid) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALCID, localCid, 0);
+ }
+ void add_remoteCid(int32_t remoteCid) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTECID, remoteCid, 0);
+ }
+ void add_psm(int32_t psm) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_PSM, psm, 0);
+ }
+ void add_localMtu(int32_t localMtu) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMTU, localMtu, 0);
+ }
+ void add_remoteMtu(int32_t remoteMtu) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMTU, remoteMtu, 0);
+ }
+ void add_localMps(int32_t localMps) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_LOCALMPS, localMps, 0);
+ }
+ void add_remoteMps(int32_t remoteMps) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_REMOTEMPS, remoteMps, 0);
+ }
+ void add_initialRxCredits(int32_t initialRxCredits) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALRXCREDITS, initialRxCredits, 0);
+ }
+ void add_initialTxCredits(int32_t initialTxCredits) {
+ fbb_.AddElement<int32_t>(LeCocChannelInfo::VT_INITIALTXCREDITS, initialTxCredits, 0);
+ }
+ explicit LeCocChannelInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ LeCocChannelInfoBuilder &operator=(const LeCocChannelInfoBuilder &);
+ flatbuffers::Offset<LeCocChannelInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<LeCocChannelInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<LeCocChannelInfo> CreateLeCocChannelInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int32_t localCid = 0,
+ int32_t remoteCid = 0,
+ int32_t psm = 0,
+ int32_t localMtu = 0,
+ int32_t remoteMtu = 0,
+ int32_t localMps = 0,
+ int32_t remoteMps = 0,
+ int32_t initialRxCredits = 0,
+ int32_t initialTxCredits = 0) {
+ LeCocChannelInfoBuilder builder_(_fbb);
+ builder_.add_initialTxCredits(initialTxCredits);
+ builder_.add_initialRxCredits(initialRxCredits);
+ builder_.add_remoteMps(remoteMps);
+ builder_.add_localMps(localMps);
+ builder_.add_remoteMtu(remoteMtu);
+ builder_.add_localMtu(localMtu);
+ builder_.add_psm(psm);
+ builder_.add_remoteCid(remoteCid);
+ builder_.add_localCid(localCid);
+ return builder_.Finish();
+}
+
+struct BtSocketOpen FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketOpenBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_NAME = 6,
+ VT_ACLCONNECTIONHANDLE = 8,
+ VT_CHANNELINFO_TYPE = 10,
+ VT_CHANNELINFO = 12,
+ VT_HUBID = 14,
+ VT_ENDPOINTID = 16
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ int32_t aclConnectionHandle() const {
+ return GetField<int32_t>(VT_ACLCONNECTIONHANDLE, 0);
+ }
+ chre::fbs::ChannelInfo channelInfo_type() const {
+ return static_cast<chre::fbs::ChannelInfo>(GetField<uint8_t>(VT_CHANNELINFO_TYPE, 0));
+ }
+ const void *channelInfo() const {
+ return GetPointer<const void *>(VT_CHANNELINFO);
+ }
+ template<typename T> const T *channelInfo_as() const;
+ const chre::fbs::LeCocChannelInfo *channelInfo_as_LeCocChannelInfo() const {
+ return channelInfo_type() == chre::fbs::ChannelInfo::LeCocChannelInfo ? static_cast<const chre::fbs::LeCocChannelInfo *>(channelInfo()) : nullptr;
+ }
+ int64_t hubId() const {
+ return GetField<int64_t>(VT_HUBID, 0);
+ }
+ int64_t endpointId() const {
+ return GetField<int64_t>(VT_ENDPOINTID, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<int32_t>(verifier, VT_ACLCONNECTIONHANDLE) &&
+ VerifyField<uint8_t>(verifier, VT_CHANNELINFO_TYPE) &&
+ VerifyOffset(verifier, VT_CHANNELINFO) &&
+ VerifyChannelInfo(verifier, channelInfo(), channelInfo_type()) &&
+ VerifyField<int64_t>(verifier, VT_HUBID) &&
+ VerifyField<int64_t>(verifier, VT_ENDPOINTID) &&
+ verifier.EndTable();
+ }
+};
+
+template<> inline const chre::fbs::LeCocChannelInfo *BtSocketOpen::channelInfo_as<chre::fbs::LeCocChannelInfo>() const {
+ return channelInfo_as_LeCocChannelInfo();
+}
+
+struct BtSocketOpenBuilder {
+ typedef BtSocketOpen Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_SOCKETID, socketId, 0);
+ }
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(BtSocketOpen::VT_NAME, name);
+ }
+ void add_aclConnectionHandle(int32_t aclConnectionHandle) {
+ fbb_.AddElement<int32_t>(BtSocketOpen::VT_ACLCONNECTIONHANDLE, aclConnectionHandle, 0);
+ }
+ void add_channelInfo_type(chre::fbs::ChannelInfo channelInfo_type) {
+ fbb_.AddElement<uint8_t>(BtSocketOpen::VT_CHANNELINFO_TYPE, static_cast<uint8_t>(channelInfo_type), 0);
+ }
+ void add_channelInfo(flatbuffers::Offset<void> channelInfo) {
+ fbb_.AddOffset(BtSocketOpen::VT_CHANNELINFO, channelInfo);
+ }
+ void add_hubId(int64_t hubId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_HUBID, hubId, 0);
+ }
+ void add_endpointId(int64_t endpointId) {
+ fbb_.AddElement<int64_t>(BtSocketOpen::VT_ENDPOINTID, endpointId, 0);
+ }
+ explicit BtSocketOpenBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketOpenBuilder &operator=(const BtSocketOpenBuilder &);
+ flatbuffers::Offset<BtSocketOpen> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketOpen>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpen(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ int32_t aclConnectionHandle = 0,
+ chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
+ flatbuffers::Offset<void> channelInfo = 0,
+ int64_t hubId = 0,
+ int64_t endpointId = 0) {
+ BtSocketOpenBuilder builder_(_fbb);
+ builder_.add_endpointId(endpointId);
+ builder_.add_hubId(hubId);
+ builder_.add_socketId(socketId);
+ builder_.add_channelInfo(channelInfo);
+ builder_.add_aclConnectionHandle(aclConnectionHandle);
+ builder_.add_name(name);
+ builder_.add_channelInfo_type(channelInfo_type);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketOpen> CreateBtSocketOpenDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ const std::vector<int8_t> *name = nullptr,
+ int32_t aclConnectionHandle = 0,
+ chre::fbs::ChannelInfo channelInfo_type = chre::fbs::ChannelInfo::NONE,
+ flatbuffers::Offset<void> channelInfo = 0,
+ int64_t hubId = 0,
+ int64_t endpointId = 0) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ return chre::fbs::CreateBtSocketOpen(
+ _fbb,
+ socketId,
+ name__,
+ aclConnectionHandle,
+ channelInfo_type,
+ channelInfo,
+ hubId,
+ endpointId);
+}
+
+struct BtSocketOpenResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketOpenResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_STATUS = 6,
+ VT_REASON = 8
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ chre::fbs::BtSocketOpenStatus status() const {
+ return static_cast<chre::fbs::BtSocketOpenStatus>(GetField<int8_t>(VT_STATUS, 0));
+ }
+ const flatbuffers::Vector<int8_t> *reason() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyField<int8_t>(verifier, VT_STATUS) &&
+ VerifyOffset(verifier, VT_REASON) &&
+ verifier.VerifyVector(reason()) &&
+ verifier.EndTable();
+ }
+};
+
+struct BtSocketOpenResponseBuilder {
+ typedef BtSocketOpenResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketOpenResponse::VT_SOCKETID, socketId, 0);
+ }
+ void add_status(chre::fbs::BtSocketOpenStatus status) {
+ fbb_.AddElement<int8_t>(BtSocketOpenResponse::VT_STATUS, static_cast<int8_t>(status), 0);
+ }
+ void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
+ fbb_.AddOffset(BtSocketOpenResponse::VT_REASON, reason);
+ }
+ explicit BtSocketOpenResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketOpenResponseBuilder &operator=(const BtSocketOpenResponseBuilder &);
+ flatbuffers::Offset<BtSocketOpenResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketOpenResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
+ BtSocketOpenResponseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ builder_.add_reason(reason);
+ builder_.add_status(status);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketOpenResponse> CreateBtSocketOpenResponseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ chre::fbs::BtSocketOpenStatus status = chre::fbs::BtSocketOpenStatus::SUCCESS,
+ const std::vector<int8_t> *reason = nullptr) {
+ auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
+ return chre::fbs::CreateBtSocketOpenResponse(
+ _fbb,
+ socketId,
+ status,
+ reason__);
+}
+
+struct BtSocketClose FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketCloseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4,
+ VT_REASON = 6
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ const flatbuffers::Vector<int8_t> *reason() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_REASON);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ VerifyOffset(verifier, VT_REASON) &&
+ verifier.VerifyVector(reason()) &&
+ verifier.EndTable();
+ }
+};
+
+struct BtSocketCloseBuilder {
+ typedef BtSocketClose Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketClose::VT_SOCKETID, socketId, 0);
+ }
+ void add_reason(flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason) {
+ fbb_.AddOffset(BtSocketClose::VT_REASON, reason);
+ }
+ explicit BtSocketCloseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketCloseBuilder &operator=(const BtSocketCloseBuilder &);
+ flatbuffers::Offset<BtSocketClose> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketClose>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketClose> CreateBtSocketClose(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> reason = 0) {
+ BtSocketCloseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ builder_.add_reason(reason);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<BtSocketClose> CreateBtSocketCloseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0,
+ const std::vector<int8_t> *reason = nullptr) {
+ auto reason__ = reason ? _fbb.CreateVector<int8_t>(*reason) : 0;
+ return chre::fbs::CreateBtSocketClose(
+ _fbb,
+ socketId,
+ reason__);
+}
+
+struct BtSocketCloseResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef BtSocketCloseResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SOCKETID = 4
+ };
+ int64_t socketId() const {
+ return GetField<int64_t>(VT_SOCKETID, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_SOCKETID) &&
+ verifier.EndTable();
+ }
+};
+
+struct BtSocketCloseResponseBuilder {
+ typedef BtSocketCloseResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_socketId(int64_t socketId) {
+ fbb_.AddElement<int64_t>(BtSocketCloseResponse::VT_SOCKETID, socketId, 0);
+ }
+ explicit BtSocketCloseResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ BtSocketCloseResponseBuilder &operator=(const BtSocketCloseResponseBuilder &);
+ flatbuffers::Offset<BtSocketCloseResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<BtSocketCloseResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<BtSocketCloseResponse> CreateBtSocketCloseResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t socketId = 0) {
+ BtSocketCloseResponseBuilder builder_(_fbb);
+ builder_.add_socketId(socketId);
+ return builder_.Finish();
+}
+
+struct VendorHubInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef VendorHubInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_NAME = 4,
+ VT_VERSION = 6,
+ VT_EXTENDED_INFO = 8
+ };
+ /// The name of the hub. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ /// Hub version
+ uint32_t version() const {
+ return GetField<uint32_t>(VT_VERSION, 0);
+ }
+ /// Additional vendor-defined data
+ const flatbuffers::Vector<uint8_t> *extended_info() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXTENDED_INFO);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<uint32_t>(verifier, VT_VERSION) &&
+ VerifyOffset(verifier, VT_EXTENDED_INFO) &&
+ verifier.VerifyVector(extended_info()) &&
+ verifier.EndTable();
+ }
+};
+
+struct VendorHubInfoBuilder {
+ typedef VendorHubInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(VendorHubInfo::VT_NAME, name);
+ }
+ void add_version(uint32_t version) {
+ fbb_.AddElement<uint32_t>(VendorHubInfo::VT_VERSION, version, 0);
+ }
+ void add_extended_info(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info) {
+ fbb_.AddOffset(VendorHubInfo::VT_EXTENDED_INFO, extended_info);
+ }
+ explicit VendorHubInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ VendorHubInfoBuilder &operator=(const VendorHubInfoBuilder &);
+ flatbuffers::Offset<VendorHubInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<VendorHubInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ uint32_t version = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> extended_info = 0) {
+ VendorHubInfoBuilder builder_(_fbb);
+ builder_.add_extended_info(extended_info);
+ builder_.add_version(version);
+ builder_.add_name(name);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<VendorHubInfo> CreateVendorHubInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<int8_t> *name = nullptr,
+ uint32_t version = 0,
+ const std::vector<uint8_t> *extended_info = nullptr) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ auto extended_info__ = extended_info ? _fbb.CreateVector<uint8_t>(*extended_info) : 0;
+ return chre::fbs::CreateVendorHubInfo(
+ _fbb,
+ name__,
+ version,
+ extended_info__);
+}
+
+struct MessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef MessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_DETAILS_TYPE = 6,
+ VT_DETAILS = 8
+ };
+ /// The hub id. -1 is reserved and 0 is invalid. 0x416e64726f696400 represents
+ /// the ContextHub service.
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ chre::fbs::MessageHubDetails details_type() const {
+ return static_cast<chre::fbs::MessageHubDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0));
+ }
+ /// Details of the message hub.
+ const void *details() const {
+ return GetPointer<const void *>(VT_DETAILS);
+ }
+ template<typename T> const T *details_as() const;
+ const chre::fbs::HubInfoResponse *details_as_HubInfoResponse() const {
+ return details_type() == chre::fbs::MessageHubDetails::HubInfoResponse ? static_cast<const chre::fbs::HubInfoResponse *>(details()) : nullptr;
+ }
+ const chre::fbs::VendorHubInfo *details_as_VendorHubInfo() const {
+ return details_type() == chre::fbs::MessageHubDetails::VendorHubInfo ? static_cast<const chre::fbs::VendorHubInfo *>(details()) : nullptr;
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) &&
+ VerifyOffset(verifier, VT_DETAILS) &&
+ VerifyMessageHubDetails(verifier, details(), details_type()) &&
+ verifier.EndTable();
+ }
+};
+
+template<> inline const chre::fbs::HubInfoResponse *MessageHub::details_as<chre::fbs::HubInfoResponse>() const {
+ return details_as_HubInfoResponse();
+}
+
+template<> inline const chre::fbs::VendorHubInfo *MessageHub::details_as<chre::fbs::VendorHubInfo>() const {
+ return details_as_VendorHubInfo();
+}
+
+struct MessageHubBuilder {
+ typedef MessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(MessageHub::VT_ID, id, 0);
+ }
+ void add_details_type(chre::fbs::MessageHubDetails details_type) {
+ fbb_.AddElement<uint8_t>(MessageHub::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0);
+ }
+ void add_details(flatbuffers::Offset<void> details) {
+ fbb_.AddOffset(MessageHub::VT_DETAILS, details);
+ }
+ explicit MessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ MessageHubBuilder &operator=(const MessageHubBuilder &);
+ flatbuffers::Offset<MessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<MessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<MessageHub> CreateMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0,
+ chre::fbs::MessageHubDetails details_type = chre::fbs::MessageHubDetails::NONE,
+ flatbuffers::Offset<void> details = 0) {
+ MessageHubBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_details(details);
+ builder_.add_details_type(details_type);
+ return builder_.Finish();
+}
+
+struct RegisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef RegisterMessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUB = 4
+ };
+ const chre::fbs::MessageHub *hub() const {
+ return GetPointer<const chre::fbs::MessageHub *>(VT_HUB);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_HUB) &&
+ verifier.VerifyTable(hub()) &&
+ verifier.EndTable();
+ }
+};
+
+struct RegisterMessageHubBuilder {
+ typedef RegisterMessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hub(flatbuffers::Offset<chre::fbs::MessageHub> hub) {
+ fbb_.AddOffset(RegisterMessageHub::VT_HUB, hub);
+ }
+ explicit RegisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ RegisterMessageHubBuilder &operator=(const RegisterMessageHubBuilder &);
+ flatbuffers::Offset<RegisterMessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<RegisterMessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<RegisterMessageHub> CreateRegisterMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::MessageHub> hub = 0) {
+ RegisterMessageHubBuilder builder_(_fbb);
+ builder_.add_hub(hub);
+ return builder_.Finish();
+}
+
+struct UnregisterMessageHub FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef UnregisterMessageHubBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4
+ };
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+};
+
+struct UnregisterMessageHubBuilder {
+ typedef UnregisterMessageHub Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(UnregisterMessageHub::VT_ID, id, 0);
+ }
+ explicit UnregisterMessageHubBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ UnregisterMessageHubBuilder &operator=(const UnregisterMessageHubBuilder &);
+ flatbuffers::Offset<UnregisterMessageHub> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<UnregisterMessageHub>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<UnregisterMessageHub> CreateUnregisterMessageHub(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0) {
+ UnregisterMessageHubBuilder builder_(_fbb);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+struct EndpointId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointIdBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUBID = 4,
+ VT_ID = 6
+ };
+ /// Id of the hub hosting the endpoint
+ int64_t hubId() const {
+ return GetField<int64_t>(VT_HUBID, 0);
+ }
+ /// The id of the endpoint scoped to the hub
+ int64_t id() const {
+ return GetField<int64_t>(VT_ID, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_HUBID) &&
+ VerifyField<int64_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointIdBuilder {
+ typedef EndpointId Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hubId(int64_t hubId) {
+ fbb_.AddElement<int64_t>(EndpointId::VT_HUBID, hubId, 0);
+ }
+ void add_id(int64_t id) {
+ fbb_.AddElement<int64_t>(EndpointId::VT_ID, id, 0);
+ }
+ explicit EndpointIdBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointIdBuilder &operator=(const EndpointIdBuilder &);
+ flatbuffers::Offset<EndpointId> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointId>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointId> CreateEndpointId(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t hubId = 0,
+ int64_t id = 0) {
+ EndpointIdBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_hubId(hubId);
+ return builder_.Finish();
+}
+
+struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef ServiceBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_FORMAT = 4,
+ VT_DESCRIPTOR = 6,
+ VT_MAJOR_VERSION = 8,
+ VT_MINOR_VERSION = 10
+ };
+ chre::fbs::RpcFormat format() const {
+ return static_cast<chre::fbs::RpcFormat>(GetField<uint8_t>(VT_FORMAT, 0));
+ }
+ /// Service descriptor. Nominally a UTF-8 string, but note that we're not
+ /// using the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *descriptor() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DESCRIPTOR);
+ }
+ /// Breaking changes should bump the major version.
+ uint32_t major_version() const {
+ return GetField<uint32_t>(VT_MAJOR_VERSION, 0);
+ }
+ /// Monotonically increasing minor version.
+ uint32_t minor_version() const {
+ return GetField<uint32_t>(VT_MINOR_VERSION, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint8_t>(verifier, VT_FORMAT) &&
+ VerifyOffset(verifier, VT_DESCRIPTOR) &&
+ verifier.VerifyVector(descriptor()) &&
+ VerifyField<uint32_t>(verifier, VT_MAJOR_VERSION) &&
+ VerifyField<uint32_t>(verifier, VT_MINOR_VERSION) &&
+ verifier.EndTable();
+ }
+};
+
+struct ServiceBuilder {
+ typedef Service Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_format(chre::fbs::RpcFormat format) {
+ fbb_.AddElement<uint8_t>(Service::VT_FORMAT, static_cast<uint8_t>(format), 0);
+ }
+ void add_descriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor) {
+ fbb_.AddOffset(Service::VT_DESCRIPTOR, descriptor);
+ }
+ void add_major_version(uint32_t major_version) {
+ fbb_.AddElement<uint32_t>(Service::VT_MAJOR_VERSION, major_version, 0);
+ }
+ void add_minor_version(uint32_t minor_version) {
+ fbb_.AddElement<uint32_t>(Service::VT_MINOR_VERSION, minor_version, 0);
+ }
+ explicit ServiceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ ServiceBuilder &operator=(const ServiceBuilder &);
+ flatbuffers::Offset<Service> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<Service>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<Service> CreateService(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> descriptor = 0,
+ uint32_t major_version = 0,
+ uint32_t minor_version = 0) {
+ ServiceBuilder builder_(_fbb);
+ builder_.add_minor_version(minor_version);
+ builder_.add_major_version(major_version);
+ builder_.add_descriptor(descriptor);
+ builder_.add_format(format);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Service> CreateServiceDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ chre::fbs::RpcFormat format = chre::fbs::RpcFormat::CUSTOM,
+ const std::vector<int8_t> *descriptor = nullptr,
+ uint32_t major_version = 0,
+ uint32_t minor_version = 0) {
+ auto descriptor__ = descriptor ? _fbb.CreateVector<int8_t>(*descriptor) : 0;
+ return chre::fbs::CreateService(
+ _fbb,
+ format,
+ descriptor__,
+ major_version,
+ minor_version);
+}
+
+struct EndpointInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointInfoBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_TYPE = 6,
+ VT_NAME = 8,
+ VT_VERSION = 10,
+ VT_REQUIRED_PERMISSIONS = 12,
+ VT_SERVICES = 14
+ };
+ const chre::fbs::EndpointId *id() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_ID);
+ }
+ chre::fbs::EndpointType type() const {
+ return static_cast<chre::fbs::EndpointType>(GetField<uint8_t>(VT_TYPE, 0));
+ }
+ /// Endpoing name. Nominally a UTF-8 string, but note that we're not using
+ /// the built-in "string" data type from FlatBuffers here, because the
+ /// generated C++ uses std::string which is not well-supported in CHRE.
+ const flatbuffers::Vector<int8_t> *name() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
+ }
+ uint32_t version() const {
+ return GetField<uint32_t>(VT_VERSION, 0);
+ }
+ /// Values from CHRE_MESSAGE_PERMISSION_*
+ uint32_t required_permissions() const {
+ return GetField<uint32_t>(VT_REQUIRED_PERMISSIONS, 0);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *services() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>> *>(VT_SERVICES);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ID) &&
+ verifier.VerifyTable(id()) &&
+ VerifyField<uint8_t>(verifier, VT_TYPE) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyVector(name()) &&
+ VerifyField<uint32_t>(verifier, VT_VERSION) &&
+ VerifyField<uint32_t>(verifier, VT_REQUIRED_PERMISSIONS) &&
+ VerifyOffset(verifier, VT_SERVICES) &&
+ verifier.VerifyVector(services()) &&
+ verifier.VerifyVectorOfTables(services()) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointInfoBuilder {
+ typedef EndpointInfo Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(flatbuffers::Offset<chre::fbs::EndpointId> id) {
+ fbb_.AddOffset(EndpointInfo::VT_ID, id);
+ }
+ void add_type(chre::fbs::EndpointType type) {
+ fbb_.AddElement<uint8_t>(EndpointInfo::VT_TYPE, static_cast<uint8_t>(type), 0);
+ }
+ void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
+ fbb_.AddOffset(EndpointInfo::VT_NAME, name);
+ }
+ void add_version(uint32_t version) {
+ fbb_.AddElement<uint32_t>(EndpointInfo::VT_VERSION, version, 0);
+ }
+ void add_required_permissions(uint32_t required_permissions) {
+ fbb_.AddElement<uint32_t>(EndpointInfo::VT_REQUIRED_PERMISSIONS, required_permissions, 0);
+ }
+ void add_services(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services) {
+ fbb_.AddOffset(EndpointInfo::VT_SERVICES, services);
+ }
+ explicit EndpointInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointInfoBuilder &operator=(const EndpointInfoBuilder &);
+ flatbuffers::Offset<EndpointInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
+ chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
+ uint32_t version = 0,
+ uint32_t required_permissions = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::Service>>> services = 0) {
+ EndpointInfoBuilder builder_(_fbb);
+ builder_.add_services(services);
+ builder_.add_required_permissions(required_permissions);
+ builder_.add_version(version);
+ builder_.add_name(name);
+ builder_.add_id(id);
+ builder_.add_type(type);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<EndpointInfo> CreateEndpointInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> id = 0,
+ chre::fbs::EndpointType type = chre::fbs::EndpointType::INVALID,
+ const std::vector<int8_t> *name = nullptr,
+ uint32_t version = 0,
+ uint32_t required_permissions = 0,
+ const std::vector<flatbuffers::Offset<chre::fbs::Service>> *services = nullptr) {
+ auto name__ = name ? _fbb.CreateVector<int8_t>(*name) : 0;
+ auto services__ = services ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::Service>>(*services) : 0;
+ return chre::fbs::CreateEndpointInfo(
+ _fbb,
+ id,
+ type,
+ name__,
+ version,
+ required_permissions,
+ services__);
+}
+
+struct RegisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef RegisterEndpointBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ENDPOINT = 4
+ };
+ const chre::fbs::EndpointInfo *endpoint() const {
+ return GetPointer<const chre::fbs::EndpointInfo *>(VT_ENDPOINT);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ENDPOINT) &&
+ verifier.VerifyTable(endpoint()) &&
+ verifier.EndTable();
+ }
+};
+
+struct RegisterEndpointBuilder {
+ typedef RegisterEndpoint Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint) {
+ fbb_.AddOffset(RegisterEndpoint::VT_ENDPOINT, endpoint);
+ }
+ explicit RegisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ RegisterEndpointBuilder &operator=(const RegisterEndpointBuilder &);
+ flatbuffers::Offset<RegisterEndpoint> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<RegisterEndpoint>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<RegisterEndpoint> CreateRegisterEndpoint(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointInfo> endpoint = 0) {
+ RegisterEndpointBuilder builder_(_fbb);
+ builder_.add_endpoint(endpoint);
+ return builder_.Finish();
+}
+
+struct UnregisterEndpoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef UnregisterEndpointBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ENDPOINT = 4
+ };
+ const chre::fbs::EndpointId *endpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_ENDPOINT);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ENDPOINT) &&
+ verifier.VerifyTable(endpoint()) &&
+ verifier.EndTable();
+ }
+};
+
+struct UnregisterEndpointBuilder {
+ typedef UnregisterEndpoint Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_endpoint(flatbuffers::Offset<chre::fbs::EndpointId> endpoint) {
+ fbb_.AddOffset(UnregisterEndpoint::VT_ENDPOINT, endpoint);
+ }
+ explicit UnregisterEndpointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ UnregisterEndpointBuilder &operator=(const UnregisterEndpointBuilder &);
+ flatbuffers::Offset<UnregisterEndpoint> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<UnregisterEndpoint>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<UnregisterEndpoint> CreateUnregisterEndpoint(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<chre::fbs::EndpointId> endpoint = 0) {
+ UnregisterEndpointBuilder builder_(_fbb);
+ builder_.add_endpoint(endpoint);
+ return builder_.Finish();
+}
+
+/// HAL->CHRE, indicates the HAL is coming up
+struct GetMessageHubsAndEndpointsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef GetMessageHubsAndEndpointsRequestBuilder Builder;
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ verifier.EndTable();
+ }
+};
+
+struct GetMessageHubsAndEndpointsRequestBuilder {
+ typedef GetMessageHubsAndEndpointsRequest Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ explicit GetMessageHubsAndEndpointsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ GetMessageHubsAndEndpointsRequestBuilder &operator=(const GetMessageHubsAndEndpointsRequestBuilder &);
+ flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsRequest> CreateGetMessageHubsAndEndpointsRequest(
+ flatbuffers::FlatBufferBuilder &_fbb) {
+ GetMessageHubsAndEndpointsRequestBuilder builder_(_fbb);
+ return builder_.Finish();
+}
+
+struct GetMessageHubsAndEndpointsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef GetMessageHubsAndEndpointsResponseBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_HUBS = 4,
+ VT_ENDPOINTS = 6
+ };
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>> *>(VT_HUBS);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *>(VT_ENDPOINTS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_HUBS) &&
+ verifier.VerifyVector(hubs()) &&
+ verifier.VerifyVectorOfTables(hubs()) &&
+ VerifyOffset(verifier, VT_ENDPOINTS) &&
+ verifier.VerifyVector(endpoints()) &&
+ verifier.VerifyVectorOfTables(endpoints()) &&
+ verifier.EndTable();
+ }
+};
+
+struct GetMessageHubsAndEndpointsResponseBuilder {
+ typedef GetMessageHubsAndEndpointsResponse Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_hubs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs) {
+ fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_HUBS, hubs);
+ }
+ void add_endpoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints) {
+ fbb_.AddOffset(GetMessageHubsAndEndpointsResponse::VT_ENDPOINTS, endpoints);
+ }
+ explicit GetMessageHubsAndEndpointsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ GetMessageHubsAndEndpointsResponseBuilder &operator=(const GetMessageHubsAndEndpointsResponseBuilder &);
+ flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<GetMessageHubsAndEndpointsResponse>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponse(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::MessageHub>>> hubs = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<chre::fbs::EndpointInfo>>> endpoints = 0) {
+ GetMessageHubsAndEndpointsResponseBuilder builder_(_fbb);
+ builder_.add_endpoints(endpoints);
+ builder_.add_hubs(hubs);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<GetMessageHubsAndEndpointsResponse> CreateGetMessageHubsAndEndpointsResponseDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<flatbuffers::Offset<chre::fbs::MessageHub>> *hubs = nullptr,
+ const std::vector<flatbuffers::Offset<chre::fbs::EndpointInfo>> *endpoints = nullptr) {
+ auto hubs__ = hubs ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::MessageHub>>(*hubs) : 0;
+ auto endpoints__ = endpoints ? _fbb.CreateVector<flatbuffers::Offset<chre::fbs::EndpointInfo>>(*endpoints) : 0;
+ return chre::fbs::CreateGetMessageHubsAndEndpointsResponse(
+ _fbb,
+ hubs__,
+ endpoints__);
+}
+
+struct OpenEndpointSessionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef OpenEndpointSessionRequestBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_FROMENDPOINT = 6,
+ VT_TOENDPOINT = 8,
+ VT_SERVICEDESCRIPTOR = 10
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ const chre::fbs::EndpointId *fromEndpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_FROMENDPOINT);
+ }
+ const chre::fbs::EndpointId *toEndpoint() const {
+ return GetPointer<const chre::fbs::EndpointId *>(VT_TOENDPOINT);
+ }
+ /// If present, describes the service definition used over the session
+ const flatbuffers::Vector<int8_t> *serviceDescriptor() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_SERVICEDESCRIPTOR);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ VerifyOffset(verifier, VT_FROMENDPOINT) &&
+ verifier.VerifyTable(fromEndpoint()) &&
+ VerifyOffset(verifier, VT_TOENDPOINT) &&
+ verifier.VerifyTable(toEndpoint()) &&
+ VerifyOffset(verifier, VT_SERVICEDESCRIPTOR) &&
+ verifier.VerifyVector(serviceDescriptor()) &&
+ verifier.EndTable();
+ }
+};
+
+struct OpenEndpointSessionRequestBuilder {
+ typedef OpenEndpointSessionRequest Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(OpenEndpointSessionRequest::VT_ID, id, 0);
+ }
+ void add_fromEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_FROMENDPOINT, fromEndpoint);
+ }
+ void add_toEndpoint(flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_TOENDPOINT, toEndpoint);
+ }
+ void add_serviceDescriptor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor) {
+ fbb_.AddOffset(OpenEndpointSessionRequest::VT_SERVICEDESCRIPTOR, serviceDescriptor);
+ }
+ explicit OpenEndpointSessionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ OpenEndpointSessionRequestBuilder &operator=(const OpenEndpointSessionRequestBuilder &);
+ flatbuffers::Offset<OpenEndpointSessionRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<OpenEndpointSessionRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequest(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
+ flatbuffers::Offset<flatbuffers::Vector<int8_t>> serviceDescriptor = 0) {
+ OpenEndpointSessionRequestBuilder builder_(_fbb);
+ builder_.add_serviceDescriptor(serviceDescriptor);
+ builder_.add_toEndpoint(toEndpoint);
+ builder_.add_fromEndpoint(fromEndpoint);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<OpenEndpointSessionRequest> CreateOpenEndpointSessionRequestDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> fromEndpoint = 0,
+ flatbuffers::Offset<chre::fbs::EndpointId> toEndpoint = 0,
+ const std::vector<int8_t> *serviceDescriptor = nullptr) {
+ auto serviceDescriptor__ = serviceDescriptor ? _fbb.CreateVector<int8_t>(*serviceDescriptor) : 0;
+ return chre::fbs::CreateOpenEndpointSessionRequest(
+ _fbb,
+ id,
+ fromEndpoint,
+ toEndpoint,
+ serviceDescriptor__);
+}
+
+struct EndpointSessionOpened FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionOpenedBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointSessionOpenedBuilder {
+ typedef EndpointSessionOpened Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionOpened::VT_ID, id, 0);
+ }
+ explicit EndpointSessionOpenedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionOpenedBuilder &operator=(const EndpointSessionOpenedBuilder &);
+ flatbuffers::Offset<EndpointSessionOpened> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionOpened>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionOpened> CreateEndpointSessionOpened(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0) {
+ EndpointSessionOpenedBuilder builder_(_fbb);
+ builder_.add_id(id);
+ return builder_.Finish();
+}
+
+struct EndpointSessionClosed FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionClosedBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_ID = 4,
+ VT_REASON = 6
+ };
+ uint16_t id() const {
+ return GetField<uint16_t>(VT_ID, 0);
+ }
+ chre::fbs::Reason reason() const {
+ return static_cast<chre::fbs::Reason>(GetField<uint8_t>(VT_REASON, 0));
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_ID) &&
+ VerifyField<uint8_t>(verifier, VT_REASON) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointSessionClosedBuilder {
+ typedef EndpointSessionClosed Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_id(uint16_t id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionClosed::VT_ID, id, 0);
+ }
+ void add_reason(chre::fbs::Reason reason) {
+ fbb_.AddElement<uint8_t>(EndpointSessionClosed::VT_REASON, static_cast<uint8_t>(reason), 0);
+ }
+ explicit EndpointSessionClosedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionClosedBuilder &operator=(const EndpointSessionClosedBuilder &);
+ flatbuffers::Offset<EndpointSessionClosed> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionClosed>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionClosed> CreateEndpointSessionClosed(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t id = 0,
+ chre::fbs::Reason reason = chre::fbs::Reason::UNSPECIFIED) {
+ EndpointSessionClosedBuilder builder_(_fbb);
+ builder_.add_id(id);
+ builder_.add_reason(reason);
+ return builder_.Finish();
+}
+
+struct EndpointSessionMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionMessageBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SESSION_ID = 4,
+ VT_TYPE = 6,
+ VT_PERMISSIONS = 8,
+ VT_DATA = 10,
+ VT_FLAGS = 12,
+ VT_SEQUENCE_NUMBER = 14
+ };
+ /// Id of session this message is being sent within
+ uint16_t session_id() const {
+ return GetField<uint16_t>(VT_SESSION_ID, 0);
+ }
+ /// Type of the message, specific to the Session protocol
+ uint32_t type() const {
+ return GetField<uint32_t>(VT_TYPE, 0);
+ }
+ /// Values from CHRE_MESSAGE_PERMISSION_*. Permissions required to read the
+ /// message.
+ uint32_t permissions() const {
+ return GetField<uint32_t>(VT_PERMISSIONS, 0);
+ }
+ const flatbuffers::Vector<uint8_t> *data() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ }
+ /// Bitmask of additional flags applied to the message:
+ /// - 0x1: Message delivery status required within 1s
+ uint32_t flags() const {
+ return GetField<uint32_t>(VT_FLAGS, 0);
+ }
+ uint32_t sequence_number() const {
+ return GetField<uint32_t>(VT_SEQUENCE_NUMBER, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
+ VerifyField<uint32_t>(verifier, VT_TYPE) &&
+ VerifyField<uint32_t>(verifier, VT_PERMISSIONS) &&
+ VerifyOffset(verifier, VT_DATA) &&
+ verifier.VerifyVector(data()) &&
+ VerifyField<uint32_t>(verifier, VT_FLAGS) &&
+ VerifyField<uint32_t>(verifier, VT_SEQUENCE_NUMBER) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointSessionMessageBuilder {
+ typedef EndpointSessionMessage Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_session_id(uint16_t session_id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionMessage::VT_SESSION_ID, session_id, 0);
+ }
+ void add_type(uint32_t type) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_TYPE, type, 0);
+ }
+ void add_permissions(uint32_t permissions) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_PERMISSIONS, permissions, 0);
+ }
+ void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
+ fbb_.AddOffset(EndpointSessionMessage::VT_DATA, data);
+ }
+ void add_flags(uint32_t flags) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_FLAGS, flags, 0);
+ }
+ void add_sequence_number(uint32_t sequence_number) {
+ fbb_.AddElement<uint32_t>(EndpointSessionMessage::VT_SEQUENCE_NUMBER, sequence_number, 0);
+ }
+ explicit EndpointSessionMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionMessageBuilder &operator=(const EndpointSessionMessageBuilder &);
+ flatbuffers::Offset<EndpointSessionMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessage(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ uint32_t type = 0,
+ uint32_t permissions = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
+ uint32_t flags = 0,
+ uint32_t sequence_number = 0) {
+ EndpointSessionMessageBuilder builder_(_fbb);
+ builder_.add_sequence_number(sequence_number);
+ builder_.add_flags(flags);
+ builder_.add_data(data);
+ builder_.add_permissions(permissions);
+ builder_.add_type(type);
+ builder_.add_session_id(session_id);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<EndpointSessionMessage> CreateEndpointSessionMessageDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ uint32_t type = 0,
+ uint32_t permissions = 0,
+ const std::vector<uint8_t> *data = nullptr,
+ uint32_t flags = 0,
+ uint32_t sequence_number = 0) {
+ auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+ return chre::fbs::CreateEndpointSessionMessage(
+ _fbb,
+ session_id,
+ type,
+ permissions,
+ data__,
+ flags,
+ sequence_number);
+}
+
+struct EndpointSessionMessageDeliveryStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EndpointSessionMessageDeliveryStatusBuilder Builder;
+ enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+ VT_SESSION_ID = 4,
+ VT_STATUS = 6
+ };
+ /// Id of session the message was sent within
+ uint16_t session_id() const {
+ return GetField<uint16_t>(VT_SESSION_ID, 0);
+ }
+ const chre::fbs::MessageDeliveryStatus *status() const {
+ return GetPointer<const chre::fbs::MessageDeliveryStatus *>(VT_STATUS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint16_t>(verifier, VT_SESSION_ID) &&
+ VerifyOffset(verifier, VT_STATUS) &&
+ verifier.VerifyTable(status()) &&
+ verifier.EndTable();
+ }
+};
+
+struct EndpointSessionMessageDeliveryStatusBuilder {
+ typedef EndpointSessionMessageDeliveryStatus Table;
+ flatbuffers::FlatBufferBuilder &fbb_;
+ flatbuffers::uoffset_t start_;
+ void add_session_id(uint16_t session_id) {
+ fbb_.AddElement<uint16_t>(EndpointSessionMessageDeliveryStatus::VT_SESSION_ID, session_id, 0);
+ }
+ void add_status(flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status) {
+ fbb_.AddOffset(EndpointSessionMessageDeliveryStatus::VT_STATUS, status);
+ }
+ explicit EndpointSessionMessageDeliveryStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ EndpointSessionMessageDeliveryStatusBuilder &operator=(const EndpointSessionMessageDeliveryStatusBuilder &);
+ flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<EndpointSessionMessageDeliveryStatus>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<EndpointSessionMessageDeliveryStatus> CreateEndpointSessionMessageDeliveryStatus(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ uint16_t session_id = 0,
+ flatbuffers::Offset<chre::fbs::MessageDeliveryStatus> status = 0) {
+ EndpointSessionMessageDeliveryStatusBuilder builder_(_fbb);
+ builder_.add_status(status);
+ builder_.add_session_id(session_id);
+ return builder_.Finish();
+}
+
/// The top-level container that encapsulates all possible messages. Note that
/// per FlatBuffers requirements, we can't use a union as the top-level
/// structure (root type), so we must wrap it in a table.
@@ -2900,6 +4827,51 @@
const chre::fbs::MessageDeliveryStatus *message_as_MessageDeliveryStatus() const {
return message_type() == chre::fbs::ChreMessage::MessageDeliveryStatus ? static_cast<const chre::fbs::MessageDeliveryStatus *>(message()) : nullptr;
}
+ const chre::fbs::BtSocketOpen *message_as_BtSocketOpen() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketOpen ? static_cast<const chre::fbs::BtSocketOpen *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketOpenResponse *message_as_BtSocketOpenResponse() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketOpenResponse ? static_cast<const chre::fbs::BtSocketOpenResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketClose *message_as_BtSocketClose() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketClose ? static_cast<const chre::fbs::BtSocketClose *>(message()) : nullptr;
+ }
+ const chre::fbs::BtSocketCloseResponse *message_as_BtSocketCloseResponse() const {
+ return message_type() == chre::fbs::ChreMessage::BtSocketCloseResponse ? static_cast<const chre::fbs::BtSocketCloseResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsRequest *message_as_GetMessageHubsAndEndpointsRequest() const {
+ return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsRequest ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(message()) : nullptr;
+ }
+ const chre::fbs::GetMessageHubsAndEndpointsResponse *message_as_GetMessageHubsAndEndpointsResponse() const {
+ return message_type() == chre::fbs::ChreMessage::GetMessageHubsAndEndpointsResponse ? static_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(message()) : nullptr;
+ }
+ const chre::fbs::RegisterMessageHub *message_as_RegisterMessageHub() const {
+ return message_type() == chre::fbs::ChreMessage::RegisterMessageHub ? static_cast<const chre::fbs::RegisterMessageHub *>(message()) : nullptr;
+ }
+ const chre::fbs::UnregisterMessageHub *message_as_UnregisterMessageHub() const {
+ return message_type() == chre::fbs::ChreMessage::UnregisterMessageHub ? static_cast<const chre::fbs::UnregisterMessageHub *>(message()) : nullptr;
+ }
+ const chre::fbs::RegisterEndpoint *message_as_RegisterEndpoint() const {
+ return message_type() == chre::fbs::ChreMessage::RegisterEndpoint ? static_cast<const chre::fbs::RegisterEndpoint *>(message()) : nullptr;
+ }
+ const chre::fbs::UnregisterEndpoint *message_as_UnregisterEndpoint() const {
+ return message_type() == chre::fbs::ChreMessage::UnregisterEndpoint ? static_cast<const chre::fbs::UnregisterEndpoint *>(message()) : nullptr;
+ }
+ const chre::fbs::OpenEndpointSessionRequest *message_as_OpenEndpointSessionRequest() const {
+ return message_type() == chre::fbs::ChreMessage::OpenEndpointSessionRequest ? static_cast<const chre::fbs::OpenEndpointSessionRequest *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionOpened *message_as_EndpointSessionOpened() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionOpened ? static_cast<const chre::fbs::EndpointSessionOpened *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionClosed *message_as_EndpointSessionClosed() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionClosed ? static_cast<const chre::fbs::EndpointSessionClosed *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessage *message_as_EndpointSessionMessage() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionMessage ? static_cast<const chre::fbs::EndpointSessionMessage *>(message()) : nullptr;
+ }
+ const chre::fbs::EndpointSessionMessageDeliveryStatus *message_as_EndpointSessionMessageDeliveryStatus() const {
+ return message_type() == chre::fbs::ChreMessage::EndpointSessionMessageDeliveryStatus ? static_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(message()) : nullptr;
+ }
/// The originating or destination client ID on the host side, used to direct
/// responses only to the client that sent the request. Although initially
/// populated by the requesting client, this is enforced to be the correct
@@ -3047,6 +5019,66 @@
return message_as_MessageDeliveryStatus();
}
+template<> inline const chre::fbs::BtSocketOpen *MessageContainer::message_as<chre::fbs::BtSocketOpen>() const {
+ return message_as_BtSocketOpen();
+}
+
+template<> inline const chre::fbs::BtSocketOpenResponse *MessageContainer::message_as<chre::fbs::BtSocketOpenResponse>() const {
+ return message_as_BtSocketOpenResponse();
+}
+
+template<> inline const chre::fbs::BtSocketClose *MessageContainer::message_as<chre::fbs::BtSocketClose>() const {
+ return message_as_BtSocketClose();
+}
+
+template<> inline const chre::fbs::BtSocketCloseResponse *MessageContainer::message_as<chre::fbs::BtSocketCloseResponse>() const {
+ return message_as_BtSocketCloseResponse();
+}
+
+template<> inline const chre::fbs::GetMessageHubsAndEndpointsRequest *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsRequest>() const {
+ return message_as_GetMessageHubsAndEndpointsRequest();
+}
+
+template<> inline const chre::fbs::GetMessageHubsAndEndpointsResponse *MessageContainer::message_as<chre::fbs::GetMessageHubsAndEndpointsResponse>() const {
+ return message_as_GetMessageHubsAndEndpointsResponse();
+}
+
+template<> inline const chre::fbs::RegisterMessageHub *MessageContainer::message_as<chre::fbs::RegisterMessageHub>() const {
+ return message_as_RegisterMessageHub();
+}
+
+template<> inline const chre::fbs::UnregisterMessageHub *MessageContainer::message_as<chre::fbs::UnregisterMessageHub>() const {
+ return message_as_UnregisterMessageHub();
+}
+
+template<> inline const chre::fbs::RegisterEndpoint *MessageContainer::message_as<chre::fbs::RegisterEndpoint>() const {
+ return message_as_RegisterEndpoint();
+}
+
+template<> inline const chre::fbs::UnregisterEndpoint *MessageContainer::message_as<chre::fbs::UnregisterEndpoint>() const {
+ return message_as_UnregisterEndpoint();
+}
+
+template<> inline const chre::fbs::OpenEndpointSessionRequest *MessageContainer::message_as<chre::fbs::OpenEndpointSessionRequest>() const {
+ return message_as_OpenEndpointSessionRequest();
+}
+
+template<> inline const chre::fbs::EndpointSessionOpened *MessageContainer::message_as<chre::fbs::EndpointSessionOpened>() const {
+ return message_as_EndpointSessionOpened();
+}
+
+template<> inline const chre::fbs::EndpointSessionClosed *MessageContainer::message_as<chre::fbs::EndpointSessionClosed>() const {
+ return message_as_EndpointSessionClosed();
+}
+
+template<> inline const chre::fbs::EndpointSessionMessage *MessageContainer::message_as<chre::fbs::EndpointSessionMessage>() const {
+ return message_as_EndpointSessionMessage();
+}
+
+template<> inline const chre::fbs::EndpointSessionMessageDeliveryStatus *MessageContainer::message_as<chre::fbs::EndpointSessionMessageDeliveryStatus>() const {
+ return message_as_EndpointSessionMessageDeliveryStatus();
+}
+
struct MessageContainerBuilder {
typedef MessageContainer Table;
flatbuffers::FlatBufferBuilder &fbb_;
@@ -3086,6 +5118,60 @@
return builder_.Finish();
}
+inline bool VerifyChannelInfo(flatbuffers::Verifier &verifier, const void *obj, ChannelInfo type) {
+ switch (type) {
+ case ChannelInfo::NONE: {
+ return true;
+ }
+ case ChannelInfo::LeCocChannelInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::LeCocChannelInfo *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyChannelInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+ if (!values || !types) return !values && !types;
+ if (values->size() != types->size()) return false;
+ for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+ if (!VerifyChannelInfo(
+ verifier, values->Get(i), types->GetEnum<ChannelInfo>(i))) {
+ return false;
+ }
+ }
+ return true;
+}
+
+inline bool VerifyMessageHubDetails(flatbuffers::Verifier &verifier, const void *obj, MessageHubDetails type) {
+ switch (type) {
+ case MessageHubDetails::NONE: {
+ return true;
+ }
+ case MessageHubDetails::HubInfoResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::HubInfoResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case MessageHubDetails::VendorHubInfo: {
+ auto ptr = reinterpret_cast<const chre::fbs::VendorHubInfo *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyMessageHubDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+ if (!values || !types) return !values && !types;
+ if (values->size() != types->size()) return false;
+ for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+ if (!VerifyMessageHubDetails(
+ verifier, values->Get(i), types->GetEnum<MessageHubDetails>(i))) {
+ return false;
+ }
+ }
+ return true;
+}
+
inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
switch (type) {
case ChreMessage::NONE: {
@@ -3219,6 +5305,66 @@
auto ptr = reinterpret_cast<const chre::fbs::MessageDeliveryStatus *>(obj);
return verifier.VerifyTable(ptr);
}
+ case ChreMessage::BtSocketOpen: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpen *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketOpenResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketOpenResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketClose: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketClose *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::BtSocketCloseResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::BtSocketCloseResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsRequest *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::GetMessageHubsAndEndpointsResponse: {
+ auto ptr = reinterpret_cast<const chre::fbs::GetMessageHubsAndEndpointsResponse *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::RegisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterMessageHub *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::UnregisterMessageHub: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterMessageHub *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::RegisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::RegisterEndpoint *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::UnregisterEndpoint: {
+ auto ptr = reinterpret_cast<const chre::fbs::UnregisterEndpoint *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::OpenEndpointSessionRequest: {
+ auto ptr = reinterpret_cast<const chre::fbs::OpenEndpointSessionRequest *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionOpened: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionOpened *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionClosed: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionClosed *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionMessage: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessage *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ChreMessage::EndpointSessionMessageDeliveryStatus: {
+ auto ptr = reinterpret_cast<const chre::fbs::EndpointSessionMessageDeliveryStatus *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
default: return true;
}
}
diff --git a/platform/shared/include/chre/platform/shared/host_protocol_chre.h b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
index 62421c0..8857fad 100644
--- a/platform/shared/include/chre/platform/shared/host_protocol_chre.h
+++ b/platform/shared/include/chre/platform/shared/host_protocol_chre.h
@@ -18,6 +18,7 @@
#define CHRE_PLATFORM_SHARED_HOST_PROTOCOL_CHRE_H_
#include <stdint.h>
+#include <cstdint>
#include "chre/core/event_loop_common.h"
#include "chre/core/nanoapp.h"
@@ -100,6 +101,15 @@
static void handleNanConfigurationUpdate(bool enabled);
+ static void handleBtSocketOpen(uint16_t hostClientId, uint64_t socketId,
+ const char *name, uint64_t endpointId,
+ uint64_t hubId, uint32_t aclConnectionHandle,
+ uint32_t localCid, uint32_t remoteCid,
+ uint32_t psm, uint32_t localMtu,
+ uint32_t remoteMtu, uint32_t localMps,
+ uint32_t remoteMps, uint32_t initialRxCredits,
+ uint32_t initialTxCredits);
+
private:
static void sendFragmentResponse(uint16_t hostClientId,
uint32_t transactionId, uint32_t fragmentId,
@@ -153,10 +163,11 @@
static bool decodeMessageFromHost(const void *message, size_t messageLen);
/**
- * Refer to the context hub HAL definition for a details of these parameters.
+ * Refer to the context hub HAL definition for a details of these
+ * parameters.
*
- * @param builder A newly constructed ChreFlatBufferBuilder that will be used
- * to encode the message
+ * @param builder A newly constructed ChreFlatBufferBuilder that will be
+ * used to encode the message
*/
static void encodeHubInfoResponse(
ChreFlatBufferBuilder &builder, const char *name, const char *vendor,
@@ -324,6 +335,32 @@
*/
static void encodeNanConfigurationRequest(ChreFlatBufferBuilder &builder,
bool enable);
+
+ /**
+ * Encodes a BT socket open response.
+ *
+ * @param builder An instance of the CHRE Flatbuffer builder.
+ * @param hostClientId Host client identifier.
+ * @param success Whether the socket open request was successful.
+ * @param reason Failure reason if success is false.
+ * @param socketId BT socket identifier.
+ */
+ static void encodeBtSocketOpenResponse(ChreFlatBufferBuilder &builder,
+ uint16_t hostClientId,
+ uint64_t socketId, bool success,
+ const char *reason);
+
+ /**
+ * Encodes a BT socket close request.
+ *
+ * @param builder An instance of the CHRE Flatbuffer builder.
+ * @param hostClientId Host client identifier.
+ * @param reason Reason socket is being closed.
+ * @param socketId BT socket identifier.
+ */
+ static void encodeBtSocketClose(ChreFlatBufferBuilder &builder,
+ uint16_t hostClientId, uint64_t socketId,
+ const char *reason);
};
} // namespace chre
diff --git a/platform/shared/include/chre/target_platform/platform_cache_management.h b/platform/shared/include/chre/platform/shared/platform_cache_management.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_cache_management.h
rename to platform/shared/include/chre/platform/shared/platform_cache_management.h
diff --git a/platform/shared/log_buffer_manager.cc b/platform/shared/log_buffer_manager.cc
index e408d0c..d090068 100644
--- a/platform/shared/log_buffer_manager.cc
+++ b/platform/shared/log_buffer_manager.cc
@@ -22,6 +22,13 @@
#include "chre/platform/shared/generated/host_messages_generated.h"
#include "chre/util/lock_guard.h"
+#ifdef CHRE_TOKENIZED_LOGGING_ENABLED
+#include "chre/platform/log.h"
+#include "pw_log_tokenized/config.h"
+#include "pw_tokenizer/encode_args.h"
+#include "pw_tokenizer/tokenize.h"
+#endif // CHRE_TOKENIZED_LOGGING_ENABLED
+
void chrePlatformLogToBuffer(chreLogLevel chreLogLevel, const char *format,
...) {
va_list args;
@@ -44,6 +51,23 @@
chre::LogBufferManagerSingleton::get()->logBtSnoop(direction, buffer, size);
}
+#ifdef CHRE_TOKENIZED_LOGGING_ENABLED
+// The callback function that must be defined to handle an encoded
+// tokenizer message.
+void EncodeTokenizedMessage(uint32_t level, pw_tokenizer_Token token,
+ pw_tokenizer_ArgTypes types, ...) {
+ va_list args;
+ va_start(args, types);
+ pw::tokenizer::EncodedMessage<pw::log_tokenized::kEncodingBufferSizeBytes>
+ encodedMessage(token, types, args);
+ va_end(args);
+
+ chrePlatformEncodedLogToBuffer(static_cast<chreLogLevel>(level),
+ encodedMessage.data_as_uint8(),
+ encodedMessage.size());
+}
+#endif // CHRE_TOKENIZED_LOGGING_ENABLED
+
namespace chre {
using LogType = fbs::LogType;
diff --git a/platform/shared/nanoapp_load_manager.cc b/platform/shared/nanoapp_load_manager.cc
index 67de637..f786823 100644
--- a/platform/shared/nanoapp_load_manager.cc
+++ b/platform/shared/nanoapp_load_manager.cc
@@ -23,12 +23,6 @@
uint32_t appVersion, uint32_t appFlags,
size_t totalBinaryLen,
uint32_t targetApiVersion) {
- if (hasPendingLoadTransaction()) {
- LOGW(
- "Pending load transaction already exists. Overriding previous"
- " transaction.");
- }
-
mCurrentLoadInfo.hostClientId = hostClientId;
mCurrentLoadInfo.transactionId = transactionId;
mCurrentLoadInfo.nextFragmentId = 1;
diff --git a/platform/shared/nanoapp_loader.cc b/platform/shared/nanoapp_loader.cc
index 9fce9ac..5eea156 100644
--- a/platform/shared/nanoapp_loader.cc
+++ b/platform/shared/nanoapp_loader.cc
@@ -27,7 +27,7 @@
#include "chre/platform/shared/debug_dump.h"
#include "chre/platform/shared/memory.h"
#include "chre/platform/shared/nanoapp/tokenized_log.h"
-#include "chre/target_platform/platform_cache_management.h"
+#include "chre/platform/shared/platform_cache_management.h"
#include "chre/util/dynamic_vector.h"
#include "chre/util/macros.h"
@@ -133,7 +133,7 @@
return cos(rad);
}
-float sqrtOverride(float val) {
+double sqrtOverride(double val) {
return sqrt(val);
}
@@ -178,6 +178,7 @@
ADD_EXPORTED_C_SYMBOL(fmaxf),
ADD_EXPORTED_C_SYMBOL(fminf),
ADD_EXPORTED_C_SYMBOL(fmodf),
+ ADD_EXPORTED_C_SYMBOL(ldexpf),
ADD_EXPORTED_C_SYMBOL(log10f),
ADD_EXPORTED_C_SYMBOL(log1pf),
ADD_EXPORTED_C_SYMBOL(log2f),
diff --git a/platform/shared/pal_ble_stub.cc b/platform/shared/pal_ble_stub.cc
index f34fdca..77f22f7 100644
--- a/platform/shared/pal_ble_stub.cc
+++ b/platform/shared/pal_ble_stub.cc
@@ -16,10 +16,7 @@
#include "chre/pal/ble.h"
-#include "chre/util/macros.h"
-
-const struct chrePalBleApi *chrePalBleGetApi(uint32_t requestedApiVersion) {
- UNUSED_VAR(requestedApiVersion);
+const struct chrePalBleApi *chrePalBleGetApi(uint32_t /*requestedApiVersion*/) {
// This stub implementation of the CHRE PAL returns nullptr to indicate that
// it is not supplied by this platform.
return nullptr;
diff --git a/platform/shared/pal_gnss_stub.cc b/platform/shared/pal_gnss_stub.cc
index 6b46b99..d279a15 100644
--- a/platform/shared/pal_gnss_stub.cc
+++ b/platform/shared/pal_gnss_stub.cc
@@ -16,7 +16,8 @@
#include "chre/pal/gnss.h"
-const struct chrePalGnssApi *chrePalGnssGetApi(uint32_t requestedApiVersion) {
+const struct chrePalGnssApi *chrePalGnssGetApi(
+ uint32_t /*requestedApiVersion*/) {
// This stub implementation of the CHRE PAL returns nullptr to indicate that
// it is not supplied by this platform.
return nullptr;
diff --git a/platform/shared/pal_sensor_stub.cc b/platform/shared/pal_sensor_stub.cc
index 235d023..10d27e7 100644
--- a/platform/shared/pal_sensor_stub.cc
+++ b/platform/shared/pal_sensor_stub.cc
@@ -16,11 +16,8 @@
#include "chre/pal/sensor.h"
-#include "chre/util/macros.h"
-
const struct chrePalSensorApi *chrePalSensorGetApi(
- uint32_t requestedApiVersion) {
- UNUSED_VAR(requestedApiVersion);
+ uint32_t /*requestedApiVersion*/) {
// This stub implementation of the CHRE PAL returns nullptr to indicate that
// it is not supplied by this platform.
diff --git a/platform/shared/pal_wifi_stub.cc b/platform/shared/pal_wifi_stub.cc
index 19d76aa..ef3059a 100644
--- a/platform/shared/pal_wifi_stub.cc
+++ b/platform/shared/pal_wifi_stub.cc
@@ -16,7 +16,8 @@
#include "chre/pal/wifi.h"
-const struct chrePalWifiApi *chrePalWifiGetApi(uint32_t requestedApiVersion) {
+const struct chrePalWifiApi *chrePalWifiGetApi(
+ uint32_t /*requestedApiVersion*/) {
// This stub implementation of the CHRE PAL returns nullptr to indicate that
// it is not supplied by this platform.
return nullptr;
diff --git a/platform/shared/pal_wwan_stub.cc b/platform/shared/pal_wwan_stub.cc
index 4233534..7908d12 100644
--- a/platform/shared/pal_wwan_stub.cc
+++ b/platform/shared/pal_wwan_stub.cc
@@ -16,7 +16,8 @@
#include "chre/pal/wwan.h"
-const struct chrePalWwanApi *chrePalWwanGetApi(uint32_t requestedApiVersion) {
+const struct chrePalWwanApi *chrePalWwanGetApi(
+ uint32_t /*requestedApiVersion*/) {
// This stub implementation of the CHRE PAL returns nullptr to indicate that
// it is not supplied by this platform.
return nullptr;
diff --git a/platform/shared/platform_ble.cc b/platform/shared/platform_ble.cc
index 54e5f1e..bf1f1cb 100644
--- a/platform/shared/platform_ble.cc
+++ b/platform/shared/platform_ble.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_BLE_SUPPORT_ENABLED
+
#include "chre/platform/platform_ble.h"
#include <cinttypes>
@@ -166,3 +168,5 @@
}
} // namespace chre
+
+#endif // CHRE_BLE_SUPPORT_ENABLED
diff --git a/platform/shared/platform_gnss.cc b/platform/shared/platform_gnss.cc
index 2c712bf..f667a63 100644
--- a/platform/shared/platform_gnss.cc
+++ b/platform/shared/platform_gnss.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_GNSS_SUPPORT_ENABLED
+
#include "chre/platform/platform_gnss.h"
#include <cinttypes>
@@ -158,3 +160,5 @@
}
} // namespace chre
+
+#endif // CHRE_GNSS_SUPPORT_ENABLED
diff --git a/platform/shared/platform_wifi.cc b/platform/shared/platform_wifi.cc
index 84c9a3c..17681fb 100644
--- a/platform/shared/platform_wifi.cc
+++ b/platform/shared/platform_wifi.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_WIFI_SUPPORT_ENABLED
+
#include "chre/platform/platform_wifi.h"
#include <cinttypes>
@@ -257,3 +259,5 @@
}
} // namespace chre
+
+#endif // CHRE_WIFI_SUPPORT_ENABLED
diff --git a/platform/shared/platform_wwan.cc b/platform/shared/platform_wwan.cc
index 2e1119a..67f1ddc 100644
--- a/platform/shared/platform_wwan.cc
+++ b/platform/shared/platform_wwan.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#ifdef CHRE_WWAN_SUPPORT_ENABLED
+
#include "chre/platform/platform_wwan.h"
#include <cinttypes>
@@ -92,3 +94,5 @@
}
} // namespace chre
+
+#endif // CHRE_WWAN_SUPPORT_ENABLED
diff --git a/platform/shared/include/chre/target_platform/platform_ble_base.h b/platform/shared/public_platform_ble_pal/chre/target_platform/platform_ble_base.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_ble_base.h
rename to platform/shared/public_platform_ble_pal/chre/target_platform/platform_ble_base.h
diff --git a/platform/shared/include/chre/target_platform/platform_debug_dump_manager_base.h b/platform/shared/public_platform_debug_dump_manager/chre/target_platform/platform_debug_dump_manager_base.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_debug_dump_manager_base.h
rename to platform/shared/public_platform_debug_dump_manager/chre/target_platform/platform_debug_dump_manager_base.h
diff --git a/platform/shared/include/chre/target_platform/platform_gnss_base.h b/platform/shared/public_platform_gnss_pal/chre/target_platform/platform_gnss_base.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_gnss_base.h
rename to platform/shared/public_platform_gnss_pal/chre/target_platform/platform_gnss_base.h
diff --git a/platform/shared/include/chre/target_platform/platform_wifi_base.h b/platform/shared/public_platform_wifi_pal/chre/target_platform/platform_wifi_base.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_wifi_base.h
rename to platform/shared/public_platform_wifi_pal/chre/target_platform/platform_wifi_base.h
diff --git a/platform/shared/include/chre/target_platform/platform_wwan_base.h b/platform/shared/public_platform_wwan_pal/chre/target_platform/platform_wwan_base.h
similarity index 100%
rename from platform/shared/include/chre/target_platform/platform_wwan_base.h
rename to platform/shared/public_platform_wwan_pal/chre/target_platform/platform_wwan_base.h
diff --git a/platform/slpi/host_link.cc b/platform/slpi/host_link.cc
index 3e07a07..a32f9e6 100644
--- a/platform/slpi/host_link.cc
+++ b/platform/slpi/host_link.cc
@@ -36,10 +36,10 @@
#include "chre/platform/slpi/power_control_util.h"
#include "chre/platform/system_time.h"
#include "chre/platform/system_timer.h"
-#include "chre/util/fixed_size_blocking_queue.h"
#include "chre/util/flatbuffers/helpers.h"
#include "chre/util/macros.h"
#include "chre/util/nested_data_ptr.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
#include "chre/util/unique_ptr.h"
#include "chre_api/chre/version.h"
@@ -928,4 +928,14 @@
#endif // CHRE_WIFI_NAN_SUPPORT_ENABLED
}
+void HostMessageHandlers::handleBtSocketOpen(
+ uint16_t /* hostClientId */, uint64_t /* socketId */,
+ const char * /* name */, uint64_t /* endpointId */, uint64_t /* hubId */,
+ uint32_t /* aclConnectionHandle */, uint32_t /* localCid */,
+ uint32_t /* remoteCid */, uint32_t /* psm */, uint32_t /* localMtu */,
+ uint32_t /* remoteMtu */, uint32_t /* localMps */, uint32_t /* remoteMps */,
+ uint32_t /* initialRxCredits */, uint32_t /* initialTxCredits */) {
+ LOGE("BT Socket offload not supported");
+}
+
} // namespace chre
diff --git a/platform/tinysys/chre_init.cc b/platform/tinysys/chre_init.cc
index 90989de..83abb87 100644
--- a/platform/tinysys/chre_init.cc
+++ b/platform/tinysys/chre_init.cc
@@ -15,8 +15,12 @@
*/
#include "chre/target_platform/chre_init.h"
+#include "chre/platform/shared/dram_vote_client.h"
BaseType_t chreTinysysInit() {
+ chre::DramVoteClientSingleton::init();
+ chre::freertos::initLogger();
+
return chre::freertos::init();
}
diff --git a/platform/tinysys/host_link.cc b/platform/tinysys/host_link.cc
index a393da9..f6f4712 100644
--- a/platform/tinysys/host_link.cc
+++ b/platform/tinysys/host_link.cc
@@ -84,24 +84,32 @@
// SCP get ack data from AP (SCP to AP)
SRAM_REGION_BSS int gChreIpiAckFromHost[2];
+#ifdef SCP_CHRE_USE_DMA
+// The min total size of a message to trigger DMA for sending/receiving.
+constexpr uint32_t kMinMessageSizeForDma = 0x1000; // 4k
+#endif
+
+// The buffer used to receive messages from AP.
+// The size should be consistent with the max sending size on the host side.
+constexpr uint32_t kChreIpiRecvBufferSize = 0x8000; // 32k
+DRAM_REGION_VARIABLE uint8_t gChreRecvBuffer[kChreIpiRecvBufferSize]
+ __attribute__((aligned(CACHE_LINE_SIZE)));
+
+#ifdef SCP_CHRE_USE_DMA
+// Rounds up the value to be aligned with CACHE_LINE_SIZE.
+static inline uint32_t alignToCacheLine(uint32_t value) {
+ // alignment must be a power of 2.
+ static_assert(CACHE_LINE_SIZE > 0 &&
+ (CACHE_LINE_SIZE & (CACHE_LINE_SIZE - 1)) == 0);
+ return (value + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1);
+}
+#endif
+
void *gChreSubregionRecvAddr;
size_t gChreSubregionRecvSize;
void *gChreSubregionSendAddr;
size_t gChreSubregionSendSize;
-// TODO(b/277235389): move it to HostLinkBase, and revisit buffer size
-// payload buffers
-#define CHRE_IPI_RECV_BUFFER_SIZE (CHRE_MESSAGE_TO_HOST_MAX_SIZE + 128)
-DRAM_REGION_VARIABLE uint32_t
- gChreRecvBuffer[CHRE_IPI_RECV_BUFFER_SIZE / sizeof(uint32_t)]
- __attribute__((aligned(CACHE_LINE_SIZE)));
-
-#ifdef SCP_CHRE_USE_DMA
-static inline uint32_t align(uint32_t target, uint32_t size) {
- return (target + size - 1) & ~(size - 1);
-}
-#endif
-
#define SCP_CHRE_MAGIC 0x67728269
struct ScpChreIpiMsg {
uint32_t magic;
@@ -132,6 +140,8 @@
NanConfigurationRequest,
PulseRequest,
PulseResponse,
+ NanoappTokenDatabaseInfo,
+ MessageDeliveryStatus,
};
struct PendingMessage {
@@ -160,7 +170,7 @@
};
constexpr size_t kOutboundQueueSize = 100;
-DRAM_REGION_VARIABLE FixedSizeBlockingQueue<PendingMessage, kOutboundQueueSize>
+SRAM_REGION_VARIABLE FixedSizeBlockingQueue<PendingMessage, kOutboundQueueSize>
gOutboundQueue;
typedef void(MessageBuilderFunction)(ChreFlatBufferBuilder &builder,
@@ -243,25 +253,9 @@
case PendingMessageType::HubInfoResponse:
result = generateHubInfoResponse(pendingMsg.data.hostClientId);
break;
-
- case PendingMessageType::NanoappListResponse:
- case PendingMessageType::LoadNanoappResponse:
- case PendingMessageType::UnloadNanoappResponse:
- case PendingMessageType::DebugDumpData:
- case PendingMessageType::DebugDumpResponse:
- case PendingMessageType::TimeSyncRequest:
- case PendingMessageType::LowPowerMicAccessRequest:
- case PendingMessageType::LowPowerMicAccessRelease:
- case PendingMessageType::EncodedLogMessage:
- case PendingMessageType::SelfTestResponse:
- case PendingMessageType::MetricLog:
- case PendingMessageType::NanConfigurationRequest:
- case PendingMessageType::PulseResponse:
+ default:
result = generateMessageFromBuilder(pendingMsg.data.builder);
break;
-
- default:
- CHRE_ASSERT_LOG(false, "Unexpected pending message type");
}
return result;
}
@@ -479,9 +473,9 @@
struct ScpChreIpiMsg msg = *(struct ScpChreIpiMsg *)data;
// check the magic number and payload size need to be copy(if need) */
- LOGV("%s: msg.magic=0x%x, msg.size=%u", __func__, msg.magic, msg.size);
+ LOGD("%s: Received a message from AP. Size=%u", __func__, msg.size);
if (msg.magic != SCP_CHRE_MAGIC) {
- LOGE("Invalid magic number, skip message");
+ LOGE("Invalid magic number: 0x%x, skip message", msg.magic);
gChreIpiAckToHost[0] = IPI_NO_MEMORY;
gChreIpiAckToHost[1] = 0;
return;
@@ -492,25 +486,38 @@
ap_to_scp(reinterpret_cast<uint32_t>(gChreSubregionRecvAddr));
#ifdef SCP_CHRE_USE_DMA
- // Using SCP DMA HW to copy the data from share memory to SCP side, ex:
- // gChreRecvBuffer gChreRecvBuffer could be a global variables or a SCP heap
- // memory at SRAM/DRAM
- scp_dma_transaction_dram(reinterpret_cast<uint32_t>(&gChreRecvBuffer[0]),
- srcAddr, msg.size, DMA_MEM_ID, NO_RESERVED);
+ if (msg.size < kMinMessageSizeForDma) {
+ dvfs_enable_DRAM_resource(CHRE_MEM_ID);
+ memcpy(static_cast<void *>(gChreRecvBuffer),
+ reinterpret_cast<void *>(srcAddr), msg.size);
+ dvfs_disable_DRAM_resource(CHRE_MEM_ID);
+ } else {
+ auto dstAddr = reinterpret_cast<uint32_t>(gChreRecvBuffer);
- // Invalid cache to update the newest data before using
- mrv_dcache_invalid_multi_addr(reinterpret_cast<uint32_t>(&gChreRecvBuffer[0]),
- align(msg.size, CACHE_LINE_SIZE));
-#else
+ // destination address for receiving data is in a cacheable memory, it
+ // should be invalidated/flushed before transferring from share buffer to
+ // SCP
+ scp_dcache_flush(dstAddr, alignToCacheLine(msg.size));
+
+ // Using SCP DMA HW to copy the data from share memory to SCP side.
+ // The dstAddr could be a global variables or a SCP heap memory at SRAM/DRAM
+ DMA_RESULT result = scp_dma_transaction_dram(dstAddr, srcAddr, msg.size,
+ DMA_MEM_ID, NO_RESERVED);
+
+ if (result != DMA_RESULT_DONE) {
+ LOGE("Failed to receive a message from AP using DMA");
+ }
+ }
+#else // SCP_CHRE_USE_DMA
+
dvfs_enable_DRAM_resource(CHRE_MEM_ID);
memcpy(static_cast<void *>(gChreRecvBuffer),
reinterpret_cast<void *>(srcAddr), msg.size);
dvfs_disable_DRAM_resource(CHRE_MEM_ID);
-#endif
+
+#endif // SCP_CHRE_USE_DMA
// process the message
- LOGV("chre_rcvbuf: 0x%x 0x%x 0x%x 0x%x", gChreRecvBuffer[0],
- gChreRecvBuffer[1], gChreRecvBuffer[2], gChreRecvBuffer[3]);
receive(static_cast<HostLinkBase *>(prdata), gChreRecvBuffer, msg.size);
// After finishing the job, akc the message to host
@@ -519,11 +526,15 @@
}
DRAM_REGION_FUNCTION void HostLinkBase::initializeIpi(void) {
- LOGV("%s", __func__);
bool success = false;
int ret;
constexpr size_t kBackgroundTaskStackSize = 1024;
+
+#ifdef PRI_CHRE_BACKGROUND
+ constexpr UBaseType_t kBackgroundTaskPriority = PRI_CHRE_BACKGROUND;
+#else
constexpr UBaseType_t kBackgroundTaskPriority = 2;
+#endif
// prepared share memory information and register the callback functions
if (!(ret = scp_get_reserve_mem_by_id(SCP_CHRE_FROM_MEM_ID,
@@ -585,20 +596,49 @@
msg.magic = SCP_CHRE_MAGIC;
msg.size = dataLen;
- // Mapping the physical address of share memory for SCP
- void *dstAddr = reinterpret_cast<void *>(
- ap_to_scp(reinterpret_cast<uint32_t>(gChreSubregionSendAddr)));
+ uint32_t dstAddr =
+ ap_to_scp(reinterpret_cast<uint32_t>(gChreSubregionSendAddr));
#ifdef SCP_CHRE_USE_DMA
- // TODO(b/288415339): use DMA for larger payload
- // No need cache operation, because src_dst handled by SCP CPU and dstAddr is
- // non-cacheable
+ if (dataLen < kMinMessageSizeForDma) {
+ dvfs_enable_DRAM_resource(CHRE_MEM_ID);
+ memcpy(reinterpret_cast<void *>(dstAddr), data, dataLen);
+ dvfs_disable_DRAM_resource(CHRE_MEM_ID);
+ } else {
+ auto srcAddr = reinterpret_cast<uint32_t>(data);
+ auto msgSize = reinterpret_cast<uint32_t>(msg.size);
+
+ // Separate the message into 2 parts, copySize and dmaSize, and use memcpy
+ // and dma to transfer them respectively. This is needed due to the
+ // alignment requirement of the dma transfer.
+ uint32_t dmaStartSrcAddr = alignToCacheLine(srcAddr);
+ uint32_t copySize = dmaStartSrcAddr - srcAddr;
+ uint32_t dmaSize = msgSize - copySize;
+
+ if (copySize > 0) {
+ dvfs_enable_DRAM_resource(CHRE_MEM_ID);
+ memcpy(reinterpret_cast<void *>(dstAddr), data, copySize);
+ dvfs_disable_DRAM_resource(CHRE_MEM_ID);
+ }
+
+ // source address for sending data is in a cacheable memory, it should
+ // be invalidated/flushed before transferring from SCP to shared buffer
+ scp_dcache_flush(dmaStartSrcAddr, alignToCacheLine(dmaSize));
+
+ // Using SCP DMA HW to copy the data from SCP to shared memory.
+ // The dstAddr could be a global variables or a SCP heap memory at SRAM/DRAM
+ DMA_RESULT result = scp_dma_transaction_dram(
+ dstAddr + copySize, dmaStartSrcAddr, dmaSize, DMA_MEM_ID, NO_RESERVED);
+
+ if (result != DMA_RESULT_DONE) {
+ LOGE("Failed to receive a message from AP using DMA");
+ }
+ }
#else
dvfs_enable_DRAM_resource(CHRE_MEM_ID);
- memcpy(dstAddr, data, dataLen);
+ memcpy(reinterpret_cast<void *>(dstAddr), data, dataLen);
dvfs_disable_DRAM_resource(CHRE_MEM_ID);
#endif
-
// NB: len param for ipi_send is in number of 32-bit words
int ret = ipi_send_compl(
IPI_OUT_C_SCP_HOST_CHRE, &msg, sizeof(msg) / sizeof(uint32_t),
@@ -607,18 +647,17 @@
LOGE("chre ipi send fail(%d)", ret);
} else {
/* check ack data for make sure IPI wasn't busy */
- LOGV("chre ipi send, check ack data: 0x%x", gChreIpiAckFromHost[0]);
if (gChreIpiAckFromHost[0] == IPI_ACTION_DONE) {
LOGV("chre ipi send done, you can send another IPI");
} else if (gChreIpiAckFromHost[0] == IPI_PIN_BUSY) {
/* you may have to re-send the IPI, or drop this one */
- LOGV(
+ LOGW(
"chre ipi send busy, user thread has not wait the IPI until job "
"finished");
} else if (gChreIpiAckFromHost[0] == IPI_NO_MEMORY) {
- LOGV("chre ipi send with wrong size(%zu)", dataLen);
+ LOGW("chre ipi send with wrong size(%zu)", dataLen);
} else {
- LOGV("chre ipi send unknown case");
+ LOGW("chre ipi send unknown case: 0x%x", gChreIpiAckFromHost[0]);
}
}
@@ -680,9 +719,21 @@
return success;
}
-bool HostLink::sendMessageDeliveryStatus(uint32_t /* messageSequenceNumber */,
- uint8_t /* errorCode */) {
- return false;
+DRAM_REGION_FUNCTION bool HostLink::sendMessageDeliveryStatus(
+ uint32_t messageSequenceNumber, uint8_t errorCode) {
+ struct DeliveryStatusData {
+ uint32_t messageSequenceNumber;
+ uint8_t errorCode;
+ } args{messageSequenceNumber, errorCode};
+
+ auto msgBuilder = [](ChreFlatBufferBuilder &builder, void *cookie) {
+ auto args = static_cast<const DeliveryStatusData *>(cookie);
+ HostProtocolChre::encodeMessageDeliveryStatus(
+ builder, args->messageSequenceNumber, args->errorCode);
+ };
+
+ return buildAndEnqueueMessage(PendingMessageType::MessageDeliveryStatus,
+ /* initialBufferSize= */ 64, msgBuilder, &args);
}
// TODO(b/285219398): HostMessageHandlers member function implementations are
@@ -704,7 +755,9 @@
}
DRAM_REGION_FUNCTION void HostMessageHandlers::handleMessageDeliveryStatus(
- uint32_t /* messageSequenceNumber */, uint8_t /* errorCode */) {}
+ uint32_t messageSequenceNumber, uint8_t errorCode) {
+ getHostCommsManager().completeTransaction(messageSequenceNumber, errorCode);
+}
DRAM_REGION_FUNCTION void HostMessageHandlers::handleHubInfoRequest(
uint16_t hostClientId) {
@@ -817,19 +870,25 @@
DRAM_REGION_FUNCTION void HostLinkBase::sendNanoappTokenDatabaseInfo(
uint64_t appId, uint32_t tokenDatabaseOffset, size_t tokenDatabaseSize) {
constexpr size_t kInitialBufferSize = 56;
- ChreFlatBufferBuilder builder(kInitialBufferSize);
- uint16_t instanceId;
- EventLoopManagerSingleton::get()->getEventLoop().findNanoappInstanceIdByAppId(
- appId, &instanceId);
- HostProtocolChre::encodeNanoappTokenDatabaseInfo(
- builder, instanceId, appId, tokenDatabaseOffset, tokenDatabaseSize);
+ struct DatabaseInfoArgs {
+ uint64_t appId;
+ uint32_t tokenDatabaseOffset;
+ size_t tokenDatabaseSize;
+ } args{appId, tokenDatabaseOffset, tokenDatabaseSize};
- if (!getHostCommsManager().send(builder.GetBufferPointer(),
- builder.GetSize())) {
- LOGE("Failed to send nanoapp token database info for AppID: 0x%016" PRIx64
- " InstanceID: %" PRIu16,
- appId, instanceId);
- }
+ auto msgBuilder = [](ChreFlatBufferBuilder &builder, void *cookie) {
+ DatabaseInfoArgs *args = static_cast<DatabaseInfoArgs *>(cookie);
+ uint16_t instanceId;
+ EventLoopManagerSingleton::get()
+ ->getEventLoop()
+ .findNanoappInstanceIdByAppId(args->appId, &instanceId);
+ HostProtocolChre::encodeNanoappTokenDatabaseInfo(
+ builder, instanceId, args->appId, args->tokenDatabaseOffset,
+ args->tokenDatabaseSize);
+ };
+
+ buildAndEnqueueMessage(PendingMessageType::NanoappTokenDatabaseInfo,
+ kInitialBufferSize, msgBuilder, &args);
}
DRAM_REGION_FUNCTION void HostLink::flushMessagesSentByNanoapp(
@@ -876,6 +935,16 @@
LOGE("%s is unsupported", __func__);
}
+DRAM_REGION_FUNCTION void HostMessageHandlers::handleBtSocketOpen(
+ uint16_t /* hostClientId */, uint64_t /* socketId */,
+ const char * /* name */, uint64_t /* endpointId */, uint64_t /* hubId */,
+ uint32_t /* aclConnectionHandle */, uint32_t /* localCid */,
+ uint32_t /* remoteCid */, uint32_t /* psm */, uint32_t /* localMtu */,
+ uint32_t /* remoteMtu */, uint32_t /* localMps */, uint32_t /* remoteMps */,
+ uint32_t /* initialRxCredits */, uint32_t /* initialTxCredits */) {
+ LOGE("BT Socket offload not supported");
+}
+
DRAM_REGION_FUNCTION void sendAudioRequest() {
auto msgBuilder = [](ChreFlatBufferBuilder &builder, void * /*cookie*/) {
HostProtocolChre::encodeLowPowerMicAccessRequest(builder);
diff --git a/platform/tinysys/include/chre/target_platform/system_timer_base.h b/platform/tinysys/include/chre/target_platform/system_timer_base.h
index 2713085..5ecdb05 100644
--- a/platform/tinysys/include/chre/target_platform/system_timer_base.h
+++ b/platform/tinysys/include/chre/target_platform/system_timer_base.h
@@ -25,6 +25,7 @@
extern "C" {
#endif
+#include "FreeRTOS.h"
#include "sensorhub/rt_timer.h"
#include "task.h"
@@ -40,7 +41,11 @@
static constexpr uint32_t kStackDepthWords = 0x200; // 2K stack size
/** Priority of the callback runner task */
+#ifdef PRI_CHRE_SYS_TIMER
+ static constexpr UBaseType_t kTaskPriority = PRI_CHRE_SYS_TIMER;
+#else
static constexpr UBaseType_t kTaskPriority = tskIDLE_PRIORITY + 4;
+#endif
/** Name of the callback runner task */
static constexpr char kTaskName[] = "ChreTimerCbRunner";
@@ -74,4 +79,4 @@
struct rt_timer rtSystemTimer;
};
} // namespace chre
-#endif // CHRE_PLATFORM_TINYSYS_SYSTEM_TIMER_BASE_H_
\ No newline at end of file
+#endif // CHRE_PLATFORM_TINYSYS_SYSTEM_TIMER_BASE_H_
diff --git a/platform/tinysys/memory.cc b/platform/tinysys/memory.cc
index 4bfd5d0..b67c836 100644
--- a/platform/tinysys/memory.cc
+++ b/platform/tinysys/memory.cc
@@ -30,7 +30,6 @@
#include "encoding.h"
#include "mt_heap.h"
#include "resource_req.h"
-#include "sensorhub/heap.h"
#ifdef __cplusplus
} // extern "C"
@@ -80,7 +79,7 @@
}
void *memoryAlloc(size_t size) {
- void *address = heap_alloc(size);
+ void *address = pvPortMalloc(size);
if (address == nullptr && size > 0) {
// Try dram if allocation from sram fails.
// DramVoteClient tracks the duration of the allocations falling back to
@@ -103,7 +102,7 @@
vPortDramFree(pointer);
DramVoteClientSingleton::get()->decrementDramVoteCount();
} else {
- heap_free(pointer);
+ vPortFree(pointer);
}
}
} // namespace chre
diff --git a/platform/tinysys/platform_cache_management.cc b/platform/tinysys/platform_cache_management.cc
index da2ba11..3e12ed1 100644
--- a/platform/tinysys/platform_cache_management.cc
+++ b/platform/tinysys/platform_cache_management.cc
@@ -16,8 +16,8 @@
#include "FreeRTOS.h"
-#include "chre/target_platform/platform_cache_management.h"
#include "chre/platform/shared/nanoapp_loader.h"
+#include "chre/platform/shared/platform_cache_management.h"
#include "dma_api.h"
diff --git a/test/simulation/chre_message_hub_test.cc b/test/simulation/chre_message_hub_test.cc
new file mode 100644
index 0000000..7b3a0d3
--- /dev/null
+++ b/test/simulation/chre_message_hub_test.cc
@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cstdint>
+#include <cstring>
+#include <optional>
+
+#include "chre/core/event_loop_manager.h"
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router.h"
+#include "chre/util/system/napp_permissions.h"
+#include "chre_api/chre/event.h"
+
+#include "pw_allocator/allocator.h"
+#include "pw_allocator/libc_allocator.h"
+#include "pw_allocator/unique_ptr.h"
+#include "pw_function/function.h"
+
+#include "gtest/gtest.h"
+#include "inc/test_util.h"
+#include "test_base.h"
+#include "test_util.h"
+
+namespace chre::message {
+namespace {
+
+constexpr size_t kNumEndpoints = 3;
+constexpr size_t kMessageSize = 5;
+constexpr MessageHubId kOtherMessageHubId = 0xDEADBEEFBEEFDEAD;
+
+EndpointInfo kEndpointInfos[kNumEndpoints] = {
+ EndpointInfo(/* id= */ 1, /* name= */ "endpoint1", /* version= */ 1,
+ EndpointType::NANOAPP, CHRE_MESSAGE_PERMISSION_NONE),
+ EndpointInfo(/* id= */ 2, /* name= */ "endpoint2", /* version= */ 10,
+ EndpointType::HOST_NATIVE, CHRE_MESSAGE_PERMISSION_BLE),
+ EndpointInfo(/* id= */ 3, /* name= */ "endpoint3", /* version= */ 100,
+ EndpointType::GENERIC, CHRE_MESSAGE_PERMISSION_AUDIO)};
+
+//! Base class for MessageHubCallbacks used in tests
+class MessageHubCallbackBase : public MessageRouter::MessageHubCallback {
+ public:
+ void forEachEndpoint(
+ const pw::Function<bool(const EndpointInfo &)> &function) override {
+ for (const EndpointInfo &endpointInfo : kEndpointInfos) {
+ if (function(endpointInfo)) {
+ return;
+ }
+ }
+ }
+
+ std::optional<EndpointInfo> getEndpointInfo(EndpointId endpointId) override {
+ for (const EndpointInfo &endpointInfo : kEndpointInfos) {
+ if (endpointInfo.id == endpointId) {
+ return endpointInfo;
+ }
+ }
+ return std::nullopt;
+ }
+};
+
+//! MessageHubCallback that stores the data passed to onMessageReceived and
+//! onSessionClosed
+class MessageHubCallbackStoreData : public MessageHubCallbackBase {
+ public:
+ MessageHubCallbackStoreData(Message *message, Session *session)
+ : mMessage(message), mSession(session) {}
+
+ bool onMessageReceived(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions,
+ const Session &session,
+ bool sentBySessionInitiator) override {
+ if (mMessage != nullptr) {
+ mMessage->sender =
+ sentBySessionInitiator ? session.initiator : session.peer;
+ mMessage->recipient =
+ sentBySessionInitiator ? session.peer : session.initiator;
+ mMessage->sessionId = session.sessionId;
+ mMessage->data = std::move(data);
+ mMessage->length = length;
+ mMessage->messageType = messageType;
+ mMessage->messagePermissions = messagePermissions;
+ }
+ return true;
+ }
+
+ void onSessionClosed(const Session &session) override {
+ if (mSession != nullptr) {
+ *mSession = session;
+ }
+ }
+
+ private:
+ Message *mMessage;
+ Session *mSession;
+};
+
+class ChreMessageHubTest : public TestBase {};
+
+TEST_F(ChreMessageHubTest, MessageRouterNanoappsAreEndpointsToChreMessageHub) {
+ class App : public TestNanoapp {
+ public:
+ App() : TestNanoapp(TestNanoappInfo{.name = "TEST1", .id = 0x1234}) {}
+ };
+
+ uint64_t appId = loadNanoapp(MakeUnique<App>());
+
+ std::optional<EndpointInfo> endpointInfoForApp =
+ MessageRouterSingleton::get()->getEndpointInfo(
+ EventLoopManagerSingleton::get()
+ ->getChreMessageHubManager()
+ .kChreMessageHubId,
+ appId);
+ ASSERT_TRUE(endpointInfoForApp.has_value());
+
+ Nanoapp *nanoapp = getNanoappByAppId(appId);
+ ASSERT_NE(nanoapp, nullptr);
+
+ EXPECT_EQ(endpointInfoForApp->id, nanoapp->getAppId());
+ EXPECT_STREQ(endpointInfoForApp->name, nanoapp->getAppName());
+ EXPECT_EQ(endpointInfoForApp->version, nanoapp->getAppVersion());
+ EXPECT_EQ(endpointInfoForApp->type, EndpointType::NANOAPP);
+ EXPECT_EQ(endpointInfoForApp->requiredPermissions,
+ nanoapp->getAppPermissions());
+}
+
+TEST_F(ChreMessageHubTest,
+ MessageRouterMultipleNanoappsAreEndpointsToChreMessageHub) {
+ class App : public TestNanoapp {
+ public:
+ App() : TestNanoapp(TestNanoappInfo{.name = "TEST1", .id = 0x1234}) {}
+ };
+
+ class App2 : public TestNanoapp {
+ public:
+ App2() : TestNanoapp(TestNanoappInfo{.name = "TEST2", .id = 0x2}) {}
+ };
+
+ uint64_t appId = loadNanoapp(MakeUnique<App>());
+ uint64_t appId2 = loadNanoapp(MakeUnique<App2>());
+ constexpr size_t kNumNanoapps = 2;
+ Nanoapp *nanoapps[kNumNanoapps] = {getNanoappByAppId(appId),
+ getNanoappByAppId(appId2)};
+ ASSERT_NE(nanoapps[0], nullptr);
+ ASSERT_NE(nanoapps[1], nullptr);
+
+ DynamicVector<EndpointInfo> endpointInfos;
+ EXPECT_TRUE(MessageRouterSingleton::get()->forEachEndpointOfHub(
+ EventLoopManagerSingleton::get()
+ ->getChreMessageHubManager()
+ .kChreMessageHubId,
+ [&endpointInfos](const EndpointInfo &endpointInfo) {
+ endpointInfos.push_back(endpointInfo);
+ return false;
+ }));
+ EXPECT_EQ(endpointInfos.size(), 2);
+
+ // Endpoint information should be nanoapp information
+ for (size_t i = 0; i < kNumNanoapps; ++i) {
+ EXPECT_EQ(endpointInfos[i].id, nanoapps[i]->getAppId());
+ EXPECT_STREQ(endpointInfos[i].name, nanoapps[i]->getAppName());
+ EXPECT_EQ(endpointInfos[i].version, nanoapps[i]->getAppVersion());
+ EXPECT_EQ(endpointInfos[i].type, EndpointType::NANOAPP);
+ EXPECT_EQ(endpointInfos[i].requiredPermissions,
+ nanoapps[i]->getAppPermissions());
+ }
+}
+
+//! Nanoapp used to test sending messages from a generic endpoint to a nanoapp
+class MessageTestApp : public TestNanoapp {
+ public:
+ MessageTestApp(std::mutex &mutex, std::condition_variable &condVar,
+ bool &messageReceivedAndValidated, bool &sessionClosed,
+ const TestNanoappInfo &info)
+ : TestNanoapp(info),
+ mMutex(mutex),
+ mCondVar(condVar),
+ mMessageReceivedAndValidated(messageReceivedAndValidated),
+ mSessionClosed(sessionClosed) {}
+
+ void handleEvent(uint32_t, uint16_t eventType,
+ const void *eventData) override {
+ switch (eventType) {
+ case CHRE_EVENT_MESSAGE_FROM_ENDPOINT: {
+ {
+ std::unique_lock<std::mutex> lock(mMutex);
+ auto *message =
+ static_cast<const struct chreMessageFromEndpointData *>(
+ eventData);
+ EXPECT_EQ(message->messageType, 1);
+ EXPECT_EQ(message->messagePermissions, 0);
+ EXPECT_EQ(message->messageSize, kMessageSize);
+
+ auto *messageData = static_cast<const std::byte *>(message->message);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ EXPECT_EQ(messageData[i], static_cast<std::byte>(i + 1));
+ }
+ mMessageReceivedAndValidated = true;
+ }
+ mCondVar.notify_one();
+ break;
+ }
+ case CHRE_EVENT_ENDPOINT_SESSION_CLOSED: {
+ {
+ std::unique_lock<std::mutex> lock(mMutex);
+ auto *session =
+ static_cast<const struct chreEndpointSessionClosedData *>(
+ eventData);
+ EXPECT_EQ(session->hubId, kOtherMessageHubId);
+ EXPECT_EQ(session->endpointId, kEndpointInfos[0].id);
+ mSessionClosed = true;
+ }
+ mCondVar.notify_one();
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ }
+
+ std::mutex &mMutex;
+ std::condition_variable &mCondVar;
+ bool &mMessageReceivedAndValidated;
+ bool &mSessionClosed;
+};
+
+TEST_F(ChreMessageHubTest, MessageRouterSendMessageToNanoapp) {
+ constexpr uint64_t kNanoappId = 0x1234;
+ std::mutex mutex;
+ std::condition_variable condVar;
+ bool messageReceivedAndValidated = false;
+ bool sessionClosed = false;
+
+ pw::allocator::LibCAllocator allocator = pw::allocator::GetLibCAllocator();
+ pw::UniquePtr<std::byte[]> messageData =
+ allocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ // Load the nanoapp
+ uint64_t appId = loadNanoapp(MakeUnique<MessageTestApp>(
+ mutex, condVar, messageReceivedAndValidated, sessionClosed,
+ TestNanoappInfo{.name = "TEST1", .id = kNanoappId}));
+
+ // Create the other hub
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub =
+ MessageRouterSingleton::get()->registerMessageHub(
+ "OTHER_TEST_HUB", kOtherMessageHubId, callback);
+ ASSERT_TRUE(messageHub.has_value());
+
+ // Open the session from the other hub:1 to the nanoapp
+ SessionId sessionId =
+ messageHub->openSession(kEndpointInfos[0].id,
+ EventLoopManagerSingleton::get()
+ ->getChreMessageHubManager()
+ .kChreMessageHubId,
+ kNanoappId);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send the message to the nanoapp
+ std::unique_lock<std::mutex> lock(mutex);
+ ASSERT_TRUE(messageHub->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0, sessionId));
+ condVar.wait(lock);
+ EXPECT_TRUE(messageReceivedAndValidated);
+
+ // Close the session
+ EXPECT_TRUE(messageHub->closeSession(sessionId));
+ condVar.wait(lock);
+ EXPECT_TRUE(sessionClosed);
+}
+
+class MessagePermissionTestApp : public MessageTestApp {
+ public:
+ MessagePermissionTestApp(std::mutex &mutex, std::condition_variable &condVar,
+ bool &messageReceivedAndValidated,
+ bool &sessionClosed, const TestNanoappInfo &info)
+ : MessageTestApp(mutex, condVar, messageReceivedAndValidated,
+ sessionClosed, info) {}
+};
+
+TEST_F(ChreMessageHubTest, MessageRouterSendMessageToNanoappPermissionFailure) {
+ CREATE_CHRE_TEST_EVENT(TRIGGER_COND_VAR, 0);
+
+ constexpr uint64_t kNanoappId = 0x1234;
+ std::mutex mutex;
+ std::condition_variable condVar;
+ bool messageReceivedAndValidated = false;
+ bool sessionClosed = false;
+
+ pw::allocator::LibCAllocator allocator = pw::allocator::GetLibCAllocator();
+ pw::UniquePtr<std::byte[]> messageData =
+ allocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ // Load the nanoapp
+ uint64_t appId = loadNanoapp(MakeUnique<MessagePermissionTestApp>(
+ mutex, condVar, messageReceivedAndValidated, sessionClosed,
+ TestNanoappInfo{
+ .name = "TEST1", .id = kNanoappId, .perms = CHRE_PERMS_BLE}));
+
+ // Create the other hub
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub =
+ MessageRouterSingleton::get()->registerMessageHub(
+ "OTHER_TEST_HUB", kOtherMessageHubId, callback);
+ ASSERT_TRUE(messageHub.has_value());
+
+ // Open the session from the other hub:1 to the nanoapp
+ SessionId sessionId =
+ messageHub->openSession(kEndpointInfos[0].id,
+ EventLoopManagerSingleton::get()
+ ->getChreMessageHubManager()
+ .kChreMessageHubId,
+ kNanoappId);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send the message to the nanoapp
+ std::unique_lock<std::mutex> lock(mutex);
+ ASSERT_TRUE(messageHub->sendMessage(
+ std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ CHRE_PERMS_AUDIO | CHRE_PERMS_GNSS, sessionId));
+
+ // Send the trigger cond var event, which will be handled after the
+ // CHRE message from endpoint event (if it is sent erroneously). If the
+ // message event is not sent, this event will unlock the condition variable.
+ // If the message event is sent, the condition variable will be unlocked
+ // after the message event is processed, setting the
+ // messageReceivedAndValidated variable to true, which will fail the test.
+ sendEventToNanoapp(appId, TRIGGER_COND_VAR);
+ condVar.wait(lock);
+ EXPECT_FALSE(messageReceivedAndValidated);
+ EXPECT_TRUE(sessionClosed);
+}
+
+} // namespace
+} // namespace chre::message
diff --git a/test/simulation/inc/test_base.h b/test/simulation/inc/test_base.h
index 6638cd6..2b5dd0a 100644
--- a/test/simulation/inc/test_base.h
+++ b/test/simulation/inc/test_base.h
@@ -25,6 +25,7 @@
#include "chre/core/nanoapp.h"
#include "chre/platform/system_time.h"
#include "chre/platform/system_timer.h"
+#include "chre/util/system/message_router.h"
#include "chre/util/time.h"
#include "test_event_queue.h"
@@ -126,6 +127,7 @@
MemberInitLogger mInitLogger;
std::thread mChreThread;
SystemTimer mSystemTimer;
+ message::MessageRouter::MessageHub mChreMessageHub;
};
} // namespace chre
diff --git a/test/simulation/inc/test_event_queue.h b/test/simulation/inc/test_event_queue.h
index 03c1364..0b22f7a 100644
--- a/test/simulation/inc/test_event_queue.h
+++ b/test/simulation/inc/test_event_queue.h
@@ -22,10 +22,10 @@
#include <cinttypes>
#include "chre/platform/memory.h"
-#include "chre/util/fixed_size_blocking_queue.h"
#include "chre/util/memory.h"
#include "chre/util/non_copyable.h"
#include "chre/util/singleton.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
#include "test_event.h"
namespace chre {
diff --git a/test/simulation/test_base.cc b/test/simulation/test_base.cc
index 5c0329e..985295f 100644
--- a/test/simulation/test_base.cc
+++ b/test/simulation/test_base.cc
@@ -17,18 +17,33 @@
#include "test_base.h"
#include <gtest/gtest.h>
+#include <pw_containers/vector.h>
#include "chre/core/event_loop_manager.h"
#include "chre/core/init.h"
#include "chre/platform/linux/platform_log.h"
#include "chre/platform/linux/task_util/task_manager.h"
+#include "chre/util/system/message_router.h"
#include "chre/util/time.h"
#include "chre_api/chre/version.h"
#include "inc/test_util.h"
#include "test_util.h"
+using ::chre::message::MessageRouter;
+using ::chre::message::MessageRouterSingleton;
+using ::chre::message::Session;
+
namespace chre {
+namespace {
+
+constexpr size_t kMaxMessageHubs = 2;
+constexpr size_t kMaxSessions = 25;
+pw::Vector<MessageRouter::MessageHubRecord, kMaxMessageHubs> gMessageHubs;
+pw::Vector<Session, kMaxSessions> gSessions;
+
+} // anonymous namespace
+
/**
* This base class initializes and runs the event loop.
*
@@ -44,14 +59,10 @@
* this test.
*/
void TestBase::SetUp() {
- // TODO(b/346903946): remove these extra prints once init failure is resolved
- printf("SetUp(): log\n");
+ MessageRouterSingleton::init(gMessageHubs, gSessions);
chre::PlatformLogSingleton::init();
- printf("SetUp(): TaskManager\n");
TaskManagerSingleton::init();
- printf("SetUp(): TestEventQueue\n");
TestEventQueueSingleton::init();
- printf("SetUp(): CHRE\n");
chre::init();
EventLoopManagerSingleton::get()->lateInit();
@@ -67,7 +78,6 @@
ASSERT_TRUE(mSystemTimer.init());
ASSERT_TRUE(mSystemTimer.set(callback, nullptr /*data*/,
Nanoseconds(getTimeoutNs())));
- printf("SetUp() complete\n");
}
void TestBase::TearDown() {
@@ -83,6 +93,7 @@
deleteNanoappInfos();
unregisterAllTestNanoapps();
chre::PlatformLogSingleton::deinit();
+ MessageRouterSingleton::deinit();
}
TEST_F(TestBase, CanLoadAndStartSingleNanoapp) {
diff --git a/tools/common.sh b/tools/common.sh
new file mode 100644
index 0000000..65d68cb
--- /dev/null
+++ b/tools/common.sh
@@ -0,0 +1,105 @@
+trap 'onExit $?' EXIT
+
+onExit() {
+ if [ "$1" != "0" ]; then
+ echo -e "\e[31m"
+ echo " ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ "
+ echo "▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌"
+ echo "▐░█▀▀▀▀▀▀▀▀▀ ▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀█░▌"
+ echo "▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌▐░▌ ▐░▌▐░▌ ▐░▌"
+ echo "▐░█▄▄▄▄▄▄▄▄▄ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄█░▌▐░▌ ▐░▌▐░█▄▄▄▄▄▄▄█░▌"
+ echo "▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░▌ ▐░▌▐░░░░░░░░░░░▌"
+ echo "▐░█▀▀▀▀▀▀▀▀▀ ▐░█▀▀▀▀█░█▀▀ ▐░█▀▀▀▀█░█▀▀ ▐░▌ ▐░▌▐░█▀▀▀▀█░█▀▀ "
+ echo "▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌ "
+ echo "▐░█▄▄▄▄▄▄▄▄▄ ▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░▌ ▐░▌ "
+ echo "▐░░░░░░░░░░░▌▐░▌ ▐░▌▐░▌ ▐░▌▐░░░░░░░░░░░▌▐░▌ ▐░▌"
+ echo " ▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀ ▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀ "
+ echo " "
+ echo -e "\e[0m"
+ fi
+}
+
+onSuccess() {
+ echo -e "\e[92m\n"
+ echo ""
+ echo " ██████ ██ ██ ██ "
+ echo " ██ ██ ██ ██ ██ "
+ echo " ██ ██ █████ ██ "
+ echo " ██ ██ ██ ██ "
+ echo " ██████ ██ ██ ██ "
+ echo ""
+ echo -e "\e[0m"
+}
+
+onWarning() {
+ echo -e "\e[33m\n"
+ echo " █████ ███ █████ █████████ ███████████ ██████ █████ █████ ██████ █████ █████████ "
+ echo " ░░███ ░███ ░░███ ███░░░░░███ ░░███░░░░░███ ░░██████ ░░███ ░░███ ░░██████ ░░███ ███░░░░░███ "
+ echo " ░███ ░███ ░███ ░███ ░███ ░███ ░███ ░███░███ ░███ ░███ ░███░███ ░███ ███ ░░░ "
+ echo " ░███ ░███ ░███ ░███████████ ░██████████ ░███░░███░███ ░███ ░███░░███░███ ░███ "
+ echo " ░░███ █████ ███ ░███░░░░░███ ░███░░░░░███ ░███ ░░██████ ░███ ░███ ░░██████ ░███ █████ "
+ echo " ░░░█████░█████░ ░███ ░███ ░███ ░███ ░███ ░░█████ ░███ ░███ ░░█████ ░░███ ░░███ "
+ echo " ░░███ ░░███ █████ █████ █████ █████ █████ ░░█████ █████ █████ ░░█████ ░░█████████ "
+ echo " ░░░ ░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░░░░░ "
+ echo -e "\e[0m"
+}
+
+doRemount() {
+ $ADB root
+ sleep 3
+ set +e
+ REMOUNT_OUTPUT="$($ADB remount -R 2>&1)"
+ REMOUNT_OUTPUT="${REMOUNT_OUTPUT,,}"
+ REMOUNT_RESULT=$?
+ echo "$REMOUNT_OUTPUT"
+ if [[ $REMOUNT_RESULT != 0 || "$REMOUNT_OUTPUT" == *"remount failed"* ]]; then
+ exit 1
+ fi
+ set -e
+ if [[ "$REMOUNT_OUTPUT" == *"rebooting"* ]]
+ then
+ echo -e "\e[93m"
+ echo "██████╗ ███████╗██████╗ ██████╗ ██████╗ ████████╗██╗███╗ ██╗ ██████╗ "
+ echo "██╔══██╗██╔════╝██╔══██╗██╔═══██╗██╔═══██╗╚══██╔══╝██║████╗ ██║██╔════╝ "
+ echo "██████╔╝█████╗ ██████╔╝██║ ██║██║ ██║ ██║ ██║██╔██╗ ██║██║ ███╗"
+ echo "██╔══██╗██╔══╝ ██╔══██╗██║ ██║██║ ██║ ██║ ██║██║╚██╗██║██║ ██║"
+ echo "██║ ██║███████╗██████╔╝╚██████╔╝╚██████╔╝ ██║ ██║██║ ╚████║╚██████╔╝"
+ echo "╚═╝ ╚═╝╚══════╝╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ "
+ echo " "
+ echo -e "\e[0m"
+ sleep 5
+ $ADB wait-for-device root && $ADB wait-for-device remount
+ fi
+}
+
+connectedProduct() {
+ echo "$($ADB shell getprop ro.build.product)"
+}
+
+checkConnectedProduct() {
+ checkDeviceRev
+
+ # Make sure connected device matches $TARGET_PRODUCT
+ CONNECTED_PRODUCT="$(connectedProduct)"
+ if [ "$TARGET_PRODUCT" != "$CONNECTED_PRODUCT" ]
+ then
+ echo "ERROR: Connected device ($CONNECTED_PRODUCT) does not match TARGET_PRODUCT. Please lunch $CONNECTED_PRODUCT first"
+ exit 1
+ fi
+}
+
+checkDeviceRev() {
+ set +e
+ GETPROP_OUTPUT="$($ADB shell getprop ro.boot.hardware.revision 2>&1)"
+ GETPROP_RESULT=$?
+ if [ $GETPROP_RESULT -ne 0 ]
+ then
+ echo "Cannot check device status via adb, please check device connection"
+ exit 1
+ elif [[ "$GETPROP_OUTPUT" =~ ^([DP]VT|MP).* ]]
+ then
+ echo "Device must be EVT or earlier for CHRE development"
+ exit 1
+ fi
+ set -e
+}
diff --git a/tools/find_improper_target_platform_files.py b/tools/find_improper_target_platform_files.py
new file mode 100644
index 0000000..6b6bbd1
--- /dev/null
+++ b/tools/find_improper_target_platform_files.py
@@ -0,0 +1,101 @@
+"""Finds header files in target_platform directories that should not be
+
+Some platform implementations have improperly used target_platform when they
+should instead use platform/<platform_name>. This script helps identify those
+files.
+
+Example usage:
+
+ python find_improper_target_platform_files.py -p ../platform -c ../platform/include
+"""
+import argparse
+import os
+import sys
+
+def find_target_platform_files(directories):
+ """
+ Lists all files recursively in the given directories and filters to those with
+ "target_platform" in their path.
+
+ Args:
+ directories: A list of directories to search.
+
+ Returns:
+ A list of file paths that contain "target_platform" in their path.
+ """
+ target_files = []
+ for directory in directories:
+ for root, _, files in os.walk(directory):
+ for file in files:
+ file_path = os.path.join(root, file)
+ if "target_platform" in file_path:
+ target_files.append(file_path)
+ return target_files
+
+def find_unincluded_files(target_files, include_directories):
+ """
+ Flags target_platform files that are not included in any C/C++ #include
+ statements within files in the include_directories.
+
+ Args:
+ target_files: A list of file paths to check.
+ include_directories: A list of directories containing files with
+ #include statements.
+
+ Returns:
+ A list of target_platform file paths that are not included.
+ """
+ unincluded_files = []
+ included_files = set()
+
+ for directory in include_directories:
+ for root, _, files in os.walk(directory):
+ for file in files:
+ file_path = os.path.join(root, file)
+ try:
+ with open(file_path, "r") as f:
+ for line in f:
+ if line.startswith("#include") and "target_platform" in line:
+ # Extract the included file name, accounting for variations in
+ # include syntax (e.g., quotes vs. angle brackets)
+ included_file = line.split()[1].strip('"<>')
+ included_files.add(included_file)
+ except UnicodeDecodeError:
+ # Skip non-text files
+ continue
+
+ print(f"target_platform files referenced in {include_directories}:")
+ for file in sorted(included_files):
+ print(f" {file}")
+
+
+ for target_file in target_files:
+ target_file_name = "target_platform/" + os.path.basename(target_file)
+ found = False
+ for included_file in included_files:
+ if included_file.endswith(target_file_name):
+ found = True
+ break
+ if not found:
+ unincluded_files.append(target_file)
+
+ return unincluded_files
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser(description="Find files in target_platform directories which are not included from common code.")
+ parser.add_argument("-p", "--platform", nargs="+", required=True, help="Directories containing target_platform subdirectories")
+ parser.add_argument("-c", "--common", nargs="+", required=True, help="Directories containing facades to platform code - all target_platform headers must appear in an #include statement in a file here")
+ args = parser.parse_args()
+
+ target_directories = args.platform
+ include_directories = args.common
+
+ target_files = find_target_platform_files(target_directories)
+ unincluded_files = find_unincluded_files(target_files, include_directories)
+
+ if len(unincluded_files):
+ print("\nThe following target_platform files do not appear in the list above:")
+ for file in sorted(unincluded_files):
+ print(f" {file}")
+ else:
+ print("All target_platform files are included.")
diff --git a/tools/tinysys_nanoapp_signer.py b/tools/tinysys_nanoapp_signer.py
new file mode 100755
index 0000000..9d57f6e
--- /dev/null
+++ b/tools/tinysys_nanoapp_signer.py
@@ -0,0 +1,125 @@
+#!/usr/bin/python
+
+#
+# Copyright 2024, The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""A script to sign nanoapps for testing purpose on tinysys platforms."""
+
+import argparse
+import ctypes
+import hashlib
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric import utils
+
+
+class HeaderInfo(ctypes.LittleEndianStructure):
+ _fields_ = [
+ ("magic_number", ctypes.c_uint32),
+ ("header_version", ctypes.c_uint32),
+ ("rollback_info", ctypes.c_uint32),
+ ("binary_length", ctypes.c_uint32),
+ ("flags", ctypes.c_uint64 * 2),
+ ("binary_sha256", ctypes.c_uint8 * 32),
+ ("reserved_chip_id", ctypes.c_uint8 * 32),
+ ("reserved_auth_config", ctypes.c_uint8 * 256),
+ ("reserved_image_config", ctypes.c_uint8 * 256),
+ ]
+
+
+def read_private_key(key_file, password):
+ with open(key_file, "rb") as file:
+ key_bytes = file.read()
+ try:
+ return serialization.load_der_private_key(key_bytes, password=password)
+ except ValueError as e:
+ pass # Not a DER private key
+
+ try:
+ return serialization.load_pem_private_key(key_bytes, password=password)
+ except ValueError:
+ pass # Not a PEM private key
+ raise ValueError("Unable to parse the key file as DER or PEM")
+
+
+def main():
+
+ parser = argparse.ArgumentParser(
+ description="Sign a binary to be authenticated on tinysys platforms"
+ )
+ parser.add_argument(
+ "private_key_file",
+ help="The private key (DER or PEM format) used to sign the binary",
+ )
+ parser.add_argument(
+ "-p",
+ "--password",
+ type=str,
+ help="Optional password encrypting the private key",
+ )
+ parser.add_argument(
+ "nanoapp", help="The name of the nanoapp binary file to be signed"
+ )
+ parser.add_argument(
+ "output_path", help="The path where the signed binary should be stored"
+ )
+ args = parser.parse_args()
+
+ # Load the binary file.
+ binary_data = None
+ with open(args.nanoapp, "rb") as binary_file:
+ binary_data = binary_file.read()
+
+ # Load ECDSA private key.
+ password = args.password.encode() if args.password else None
+ private_key = read_private_key(args.private_key_file, password)
+
+ # Generate a zero-filled header.
+ header = bytearray(0x1000)
+
+ # Fill the public key.
+ public_key_numbers = private_key.public_key().public_numbers()
+ header[0x200:0x220] = public_key_numbers.x.to_bytes(32, "big")
+ header[0x220:0x240] = public_key_numbers.y.to_bytes(32, "big")
+
+ # Fill header_info.
+ sha256_hasher = hashlib.sha256()
+ sha256_hasher.update(binary_data)
+ header_info = HeaderInfo(
+ magic_number=0x45524843,
+ header_version=1,
+ binary_length=len(binary_data),
+ binary_sha256=(ctypes.c_uint8 * 32)(*sha256_hasher.digest()),
+ )
+ header_info_bytes = bytes(header_info)
+ header[0x400 : 0x400 + len(header_info_bytes)] = header_info_bytes
+
+ # Generate the signature.
+ signature = private_key.sign(header[0x200:], ec.ECDSA(hashes.SHA256()))
+ r, s = utils.decode_dss_signature(signature)
+ r_bytes = r.to_bytes(32, "big")
+ s_bytes = s.to_bytes(32, "big")
+ header[:32] = r_bytes
+ header[32:64] = s_bytes
+
+ with open(f"{args.output_path}/{args.nanoapp}", "wb") as output:
+ output.write(header)
+ output.write(binary_data)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt
new file mode 100644
index 0000000..3d4554f
--- /dev/null
+++ b/util/CMakeLists.txt
@@ -0,0 +1,201 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+pw_add_library(chre.util STATIC
+ HEADERS
+ include/chre/util/always_false.h
+ include/chre/util/array_queue.h
+ include/chre/util/array_queue_impl.h
+ include/chre/util/blocking_segmented_queue.h
+ include/chre/util/buffer.h
+ include/chre/util/buffer_base.h
+ include/chre/util/conditional_lock_guard.h
+ include/chre/util/conditional_lock_guard_impl.h
+ include/chre/util/container_support.h
+ include/chre/util/copyable_fixed_size_vector.h
+ include/chre/util/duplicate_message_detector.h
+ include/chre/util/dynamic_vector.h
+ include/chre/util/dynamic_vector_base.h
+ include/chre/util/dynamic_vector_impl.h
+ include/chre/util/enum.h
+ include/chre/util/fixed_size_vector.h
+ include/chre/util/fixed_size_vector_impl.h
+ include/chre/util/fragmentation_manager.h
+ include/chre/util/fragmentation_manager_impl.h
+ include/chre/util/hash.h
+ include/chre/util/heap.h
+ include/chre/util/heap_impl.h
+ include/chre/util/host/assert.h
+ include/chre/util/intrusive_list.h
+ include/chre/util/intrusive_list_base.h
+ include/chre/util/intrusive_list_impl.h
+ include/chre/util/lock_guard.h
+ include/chre/util/lock_guard_impl.h
+ include/chre/util/log_common.h
+ include/chre/util/macros.h
+ include/chre/util/memory.h
+ include/chre/util/memory_impl.h
+ include/chre/util/memory_pool.h
+ include/chre/util/memory_pool_impl.h
+ include/chre/util/nested_data_ptr.h
+ include/chre/util/non_copyable.h
+ include/chre/util/optional.h
+ include/chre/util/optional_impl.h
+ include/chre/util/priority_queue.h
+ include/chre/util/priority_queue_impl.h
+ include/chre/util/raw_storage.h
+ include/chre/util/scope_timer.h
+ include/chre/util/scope_timer_impl.h
+ include/chre/util/segmented_queue.h
+ include/chre/util/segmented_queue_impl.h
+ include/chre/util/singleton.h
+ include/chre/util/singleton_impl.h
+ include/chre/util/throttle.h
+ include/chre/util/time.h
+ include/chre/util/time_impl.h
+ include/chre/util/toolchain.h
+ include/chre/util/unique_ptr.h
+ include/chre/util/unique_ptr_impl.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.memory
+ chre.platform.system_time
+ chre.util.nanoapp
+ chre.variant.config
+
+ # TODO(b/376249597) Move the synchronized expandable memory pool, fixed
+ # size blocking queue, and synchronized memory pool to chre.util.system.
+ chre.platform.condition_variable
+ chre.platform.mutex
+ SOURCES
+ buffer_base.cc
+ duplicate_message_detector.cc
+ dynamic_vector_base.cc
+ hash.cc
+ intrusive_list_base.cc
+)
+
+pw_add_library(chre.util.flatbuffers INTERFACE
+ HEADERS
+ include/chre/util/flatbuffers/helpers.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.util
+ chre.variant.config
+ chre_third_party.flatbuffers
+)
+
+pw_add_library(chre.util.host INTERFACE
+ HEADERS
+ include/chre/util/host/assert.h
+ PUBLIC_INCLUDES
+ include
+)
+
+
+pw_add_library(chre.util.nanoapp STATIC
+ HEADERS
+ include/chre/util/nanoapp/app_id.h
+ include/chre/util/nanoapp/assert.h
+ include/chre/util/nanoapp/audio.h
+ include/chre/util/nanoapp/ble.h
+ include/chre/util/nanoapp/callbacks.h
+ include/chre/util/nanoapp/debug.h
+ include/chre/util/nanoapp/log.h
+ include/chre/util/nanoapp/math.h
+ include/chre/util/nanoapp/string.h
+ include/chre/util/nanoapp/tagged_log.h
+ include/chre/util/nanoapp/wifi.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.platform.assert
+ chre.platform.log
+ chre.util
+ chre.variant.config
+ pw_tokenizer
+ SOURCES
+ nanoapp/audio.cc
+ nanoapp/ble.cc
+ nanoapp/callbacks.cc
+ nanoapp/debug.cc
+ nanoapp/string.cc
+ nanoapp/wifi.cc
+)
+
+pw_add_library(chre.util.pigweed STATIC
+ HEADERS
+ include/chre/util/pigweed/chre_channel_output.h
+ include/chre/util/pigweed/permission.h
+ include/chre/util/pigweed/rpc_client.h
+ include/chre/util/pigweed/rpc_common.h
+ include/chre/util/pigweed/rpc_helper.h
+ include/chre/util/pigweed/rpc_server.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.util
+ chre.util.nanoapp
+ chre.variant.config
+ pw_rpc.client
+ pw_rpc.common
+ pw_rpc.server
+ pw_span
+ SOURCES
+ pigweed/chre_channel_output.cc
+ pigweed/rpc_client.cc
+ pigweed/rpc_helper.cc
+ pigweed/rpc_server.cc
+ PRIVATE_DEPS
+ pw_status
+)
+
+pw_add_library(chre.util.system STATIC
+ HEADERS
+ include/chre/util/system/atomic_spsc_queue.h
+ include/chre/util/system/ble_util.h
+ include/chre/util/system/debug_dump.h
+ include/chre/util/system/event_callbacks.h
+ include/chre/util/system/fixed_size_blocking_queue.h
+ include/chre/util/system/fixed_size_blocking_queue_impl.h
+ include/chre/util/system/message_common.h
+ include/chre/util/system/message_router.h
+ include/chre/util/system/napp_header_utils.h
+ include/chre/util/system/napp_permissions.h
+ include/chre/util/system/ref_base.h
+ include/chre/util/system/shared_ptr.h
+ include/chre/util/system/shared_ptr_impl.h
+ include/chre/util/system/synchronized_expandable_memory_pool.h
+ include/chre/util/system/synchronized_expandable_memory_pool_impl.h
+ include/chre/util/system/synchronized_memory_pool.h
+ include/chre/util/system/synchronized_memory_pool_impl.h
+ include/chre/util/system/stats_container.h
+ include/chre/util/system/transaction_manager.h
+ include/chre/util/system/transaction_manager_impl.h
+ include/chre/util/system/wifi_util.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ chre.chre_api
+ chre.core
+ chre.platform.assert
+ chre.platform.atomic
+ chre.platform.memory
+ chre.platform.mutex
+ chre.platform.system_time
+ chre.util
+ chre.variant.config
+ pw_allocator.deallocator
+ SOURCES
+ system/ble_util.cc
+ system/event_callbacks.cc
+ system/debug_dump.cc
+ system/message_router.cc
+ PRIVATE_DEPS
+ chre.platform.log
+)
diff --git a/util/include/chre/util/blocking_segmented_queue.h b/util/include/chre/util/blocking_segmented_queue.h
index 92d8dea..5ac45e2 100644
--- a/util/include/chre/util/blocking_segmented_queue.h
+++ b/util/include/chre/util/blocking_segmented_queue.h
@@ -17,8 +17,8 @@
#ifndef CHRE_UTIL_BLOCKING_SEGMENTED_QUEUE_H_
#define CHRE_UTIL_BLOCKING_SEGMENTED_QUEUE_H_
-#include "chre/util/fixed_size_blocking_queue.h"
#include "chre/util/segmented_queue.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
namespace chre {
/**
* Similar but memory efficient version of chre::FixedSizeBlockingQueue.
diff --git a/util/include/chre/util/intrusive_list.h b/util/include/chre/util/intrusive_list.h
index 4a394d1..a74fa9c 100644
--- a/util/include/chre/util/intrusive_list.h
+++ b/util/include/chre/util/intrusive_list.h
@@ -110,7 +110,7 @@
using Node = ::chre::intrusive_list_internal::Node;
public:
- Iterator(Node *node) : mNode(node){};
+ Iterator(Node *node) : mNode(node) {}
ListNode<ElementType> &operator*() const {
return *reinterpret_cast<ListNode<ElementType> *>(mNode);
diff --git a/util/include/chre/util/log_common.h b/util/include/chre/util/log_common.h
index 3032650..e00442a 100644
--- a/util/include/chre/util/log_common.h
+++ b/util/include/chre/util/log_common.h
@@ -61,6 +61,6 @@
/**
* Logs an out of memory error with file and line number.
*/
-#define LOG_OOM() LOGE("OOM at %s:%d", CHRE_FILENAME, __LINE__)
+#define LOG_OOM() LOGE("OOM at " CHRE_FILENAME ":%d", __LINE__)
#endif // CHRE_UTIL_LOG_COMMON_H_
diff --git a/util/include/chre/util/memory_impl.h b/util/include/chre/util/memory_impl.h
index 96f08ca..fc5e6e2 100644
--- a/util/include/chre/util/memory_impl.h
+++ b/util/include/chre/util/memory_impl.h
@@ -18,6 +18,7 @@
#define CHRE_UTIL_MEMORY_IMPL_H_
// IWYU pragma: private
+#include <cstddef>
#include <cstring>
#include <new>
#include <type_traits>
diff --git a/util/include/chre/util/nanoapp/assert.h b/util/include/chre/util/nanoapp/assert.h
index ddc7afe..f4dbb85 100644
--- a/util/include/chre/util/nanoapp/assert.h
+++ b/util/include/chre/util/nanoapp/assert.h
@@ -37,7 +37,7 @@
#define CHRE_ASSERT(condition) \
do { \
if (!(condition)) { \
- chreLog(CHRE_LOG_ERROR, "CHRE_ASSERT at %s:%d", CHRE_FILENAME, \
+ chreLog(CHRE_LOG_ERROR, "CHRE_ASSERT at " CHRE_FILENAME ":%d", \
__LINE__); \
chreAbort(UINT32_MAX); \
} \
diff --git a/util/include/chre/util/nanoapp/ble.h b/util/include/chre/util/nanoapp/ble.h
index fade65a..475d669 100644
--- a/util/include/chre/util/nanoapp/ble.h
+++ b/util/include/chre/util/nanoapp/ble.h
@@ -48,6 +48,17 @@
/** Length of Google manufacturer data filter. */
constexpr uint16_t kGoogleManufactureDataLength = 4;
+/**
+ * The public address of the known (bonded) BLE advertiser in big endian byte
+ * order. Change this address to the public identity address of the advertiser
+ * in the test.
+ *
+ * Example: To filter on the address (01:02:03:AB:CD:EF), use
+ * {0x01:0x02:0x03:0xAB:0xCD:0xEF}.
+ */
+constexpr uint8_t kBroadcasterAddress[CHRE_BLE_ADDRESS_LEN] = {
+ 0x01, 0x02, 0x03, 0xAB, 0xCD, 0xEF};
+
/** The Google manufacturer ID followed by some data. */
constexpr uint8_t kGoogleManufactureData[kGoogleManufactureDataLength] = {
0xE0, 0x00, 0xAA, 0xFE};
@@ -58,10 +69,14 @@
/** The number of generic filters (equal to the number of known beacons). */
constexpr uint8_t kNumScanFilters = 2;
-
/** The number of manufacturer data filters. */
constexpr uint8_t kNumManufacturerDataFilters = 1;
+/**
+ * The number of broadcaster address filters (equal to the number of known
+ * public advertiser addresses).
+ */
+constexpr uint8_t kNumBroadcasterFilters = 1;
} // namespace ble_constants
/**
@@ -118,6 +133,24 @@
chreBleGenericFilter *genericFilters,
struct chreBleScanFilterV1_9 &filter);
+/**
+ * Creates a chreBleScanFilter that filters for the Google eddystone UUID,
+ * the Google nearby fastpair UUID, public identity address of a bonded device,
+ * and a RSSI threshold of kRssiThreshold.
+ *
+ * @param filter (out) the output filter.
+ * @param broadcasterFilters (out) the output broadcaster address filters
+ * array.
+ * @param numBroadcasterFilters the size of the broadcaster address filters
+ * array. must be >= kNumBroadcasterFilters.
+ *
+ * @return true the operation was successful
+ * @return false the operation was not successful
+ */
+bool createBleScanFilterForAdvertiser(
+ struct chreBleScanFilterV1_9 &filter,
+ chreBleBroadcasterAddressFilter *broadcasterFilters,
+ uint8_t numBroadcasterFilters);
} // namespace chre
#endif // CHRE_UTIL_NANOAPP_BLE_H_
diff --git a/util/include/chre/util/optional.h b/util/include/chre/util/optional.h
index d3fc092..24394cc 100644
--- a/util/include/chre/util/optional.h
+++ b/util/include/chre/util/optional.h
@@ -36,7 +36,7 @@
/**
* Default constructs the optional object with no initial value.
*/
- Optional() = default;
+ constexpr Optional() : mObject() {}
/**
* Default copy constructor.
diff --git a/util/include/chre/util/fixed_size_blocking_queue.h b/util/include/chre/util/system/fixed_size_blocking_queue.h
similarity index 93%
rename from util/include/chre/util/fixed_size_blocking_queue.h
rename to util/include/chre/util/system/fixed_size_blocking_queue.h
index 58277fe..81e631e 100644
--- a/util/include/chre/util/fixed_size_blocking_queue.h
+++ b/util/include/chre/util/system/fixed_size_blocking_queue.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_H_
-#define CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_H_
+#ifndef CHRE_UTIL_SYSTEM_FIXED_SIZE_BLOCKING_QUEUE_H_
+#define CHRE_UTIL_SYSTEM_FIXED_SIZE_BLOCKING_QUEUE_H_
#include <deque>
@@ -120,6 +120,6 @@
} // namespace chre
-#include "chre/util/fixed_size_blocking_queue_impl.h" // IWYU pragma: export
+#include "chre/util/system/fixed_size_blocking_queue_impl.h" // IWYU pragma: export
-#endif // CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_H_
+#endif // CHRE_UTIL_SYSTEM_FIXED_SIZE_BLOCKING_QUEUE_H_
diff --git a/util/include/chre/util/fixed_size_blocking_queue_impl.h b/util/include/chre/util/system/fixed_size_blocking_queue_impl.h
similarity index 94%
rename from util/include/chre/util/fixed_size_blocking_queue_impl.h
rename to util/include/chre/util/system/fixed_size_blocking_queue_impl.h
index 43911df..adea3f8 100644
--- a/util/include/chre/util/fixed_size_blocking_queue_impl.h
+++ b/util/include/chre/util/system/fixed_size_blocking_queue_impl.h
@@ -14,12 +14,12 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_
-#define CHRE_UTIL_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_
+#ifndef CHRE_UTIL_SYSTEM_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_
+#define CHRE_UTIL_SYSTEM_FIXED_SIZE_BLOCKING_QUEUE_IMPL_H_
// IWYU pragma: private
-#include "chre/util/fixed_size_blocking_queue.h"
#include "chre/util/lock_guard.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
namespace chre {
diff --git a/util/include/chre/util/system/message_common.h b/util/include/chre/util/system/message_common.h
new file mode 100644
index 0000000..f314f32
--- /dev/null
+++ b/util/include/chre/util/system/message_common.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_UTIL_SYSTEM_MESSAGE_COMMON_H_
+#define CHRE_UTIL_SYSTEM_MESSAGE_COMMON_H_
+
+#include <pw_allocator/unique_ptr.h>
+#include <pw_function/function.h>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace chre::message {
+
+//! The ID of a MessageHub
+using MessageHubId = uint64_t;
+
+//! The ID of an endpoint
+using EndpointId = uint64_t;
+
+//! The ID of a session
+using SessionId = uint16_t;
+
+//! An invalid MessageHub ID
+constexpr MessageHubId MESSAGE_HUB_ID_INVALID = 0;
+
+//! An invalid endpoint ID
+constexpr EndpointId ENDPOINT_ID_INVALID = 0;
+
+//! An invalid session ID
+constexpr SessionId SESSION_ID_INVALID = UINT16_MAX;
+
+//! Endpoint types
+enum class EndpointType : uint8_t {
+ HOST_FRAMEWORK = 1,
+ HOST_APP = 2,
+ HOST_NATIVE = 3,
+ NANOAPP = 4,
+ GENERIC = 5,
+};
+
+//! Endpoint permissions
+//! This should match CHRE permissions.
+// TODO(b/373417024): Update permissions to this typed name in all MessageRouter
+// code
+enum class EndpointPermission : uint32_t {
+ NONE = 0,
+ AUDIO = 1,
+ GNSS = 1 << 1,
+ WIFI = 1 << 2,
+ WWAN = 1 << 3,
+ BLE = 1 << 4,
+};
+
+//! Represents a single endpoint connected to a MessageHub
+struct Endpoint {
+ MessageHubId messageHubId;
+ EndpointId endpointId;
+
+ bool operator==(const Endpoint &other) const {
+ return messageHubId == other.messageHubId && endpointId == other.endpointId;
+ }
+
+ bool operator!=(const Endpoint &other) const {
+ return !(*this == other);
+ }
+};
+
+//! Represents a session between two endpoints
+struct Session {
+ SessionId sessionId;
+ Endpoint initiator;
+ Endpoint peer;
+
+ bool operator==(const Session &other) const {
+ return sessionId == other.sessionId && initiator == other.initiator &&
+ peer == other.peer;
+ }
+
+ bool operator!=(const Session &other) const {
+ return !(*this == other);
+ }
+
+ bool isEquivalent(const Session &other) const {
+ return (initiator == other.initiator && peer == other.peer) ||
+ (initiator == other.peer && peer == other.initiator);
+ }
+};
+
+//! Represents a message sent using the MessageRouter
+struct Message {
+ Endpoint sender;
+ Endpoint recipient;
+ SessionId sessionId;
+ pw::UniquePtr<std::byte[]> data;
+ size_t length;
+ uint32_t messageType;
+ uint32_t messagePermissions;
+
+ Message()
+ : sessionId(SESSION_ID_INVALID),
+ data(nullptr),
+ length(0),
+ messageType(0),
+ messagePermissions(0) {}
+ Message(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions, Session session,
+ bool sentBySessionInitiator)
+ : sender(sentBySessionInitiator ? session.initiator : session.peer),
+ recipient(sentBySessionInitiator ? session.peer : session.initiator),
+ sessionId(session.sessionId),
+ data(std::move(data)),
+ length(length),
+ messageType(messageType),
+ messagePermissions(messagePermissions) {}
+ Message(Message &&other)
+ : sender(other.sender),
+ recipient(other.recipient),
+ sessionId(other.sessionId),
+ data(std::move(other.data)),
+ length(other.length),
+ messageType(other.messageType),
+ messagePermissions(other.messagePermissions) {}
+
+ Message(const Message &) = delete;
+ Message &operator=(const Message &) = delete;
+
+ Message &operator=(Message &&other) {
+ sender = other.sender;
+ recipient = other.recipient;
+ sessionId = other.sessionId;
+ data = std::move(other.data);
+ length = other.length;
+ messageType = other.messageType;
+ messagePermissions = other.messagePermissions;
+ return *this;
+ }
+};
+
+//! Represents information about an endpoint
+//! Service information is stored in ServiceManager
+struct EndpointInfo {
+ static constexpr size_t kMaxNameLength = 50;
+
+ EndpointInfo(EndpointId id, const char *name, uint32_t version,
+ EndpointType type, uint32_t requiredPermissions)
+ : id(id),
+ version(version),
+ type(type),
+ requiredPermissions(requiredPermissions) {
+ if (name != nullptr) {
+ std::strncpy(this->name, name, kMaxNameLength);
+ } else {
+ this->name[0] = '\0';
+ }
+ this->name[kMaxNameLength] = '\0';
+ }
+
+ EndpointId id;
+ char name[kMaxNameLength + 1];
+ uint32_t version;
+ EndpointType type;
+ uint32_t requiredPermissions;
+
+ bool operator==(const EndpointInfo &other) const {
+ return id == other.id && version == other.version && type == other.type &&
+ requiredPermissions == other.requiredPermissions &&
+ std::strcmp(name, other.name) == 0;
+ }
+
+ bool operator!=(const EndpointInfo &other) const {
+ return !(*this == other);
+ }
+};
+
+//! Represents information about a MessageHub
+struct MessageHubInfo {
+ MessageHubId id;
+ const char *name;
+
+ bool operator==(const MessageHubInfo &other) const {
+ return id == other.id && std::strcmp(name, other.name) == 0;
+ }
+
+ bool operator!=(const MessageHubInfo &other) const {
+ return !(*this == other);
+ }
+};
+
+} // namespace chre::message
+
+#endif // CHRE_UTIL_SYSTEM_MESSAGE_COMMON_H_
diff --git a/util/include/chre/util/system/message_router.h b/util/include/chre/util/system/message_router.h
new file mode 100644
index 0000000..089f149
--- /dev/null
+++ b/util/include/chre/util/system/message_router.h
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_H_
+#define CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_H_
+
+#include <pw_allocator/unique_ptr.h>
+#include <pw_containers/vector.h>
+#include <pw_function/function.h>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+
+#include "chre/platform/mutex.h"
+#include "chre/util/singleton.h"
+#include "chre/util/system/message_common.h"
+
+namespace chre::message {
+
+//! MessageRouter routes messages between endpoints connected to MessageHubs. It
+//! provides an API for registering MessageHubs, opening and closing sessions,
+//! and sending messages between endpoints. Each MessageHub is expected to
+//! register a callback to handle messages sent to its endpoints and other
+//! functions to provide information about the endpoints connected to it.
+//!
+//! MessageRouter is thread-safe.
+//!
+//! Usage:
+//! 1. Create a MessageRouter instance.
+//! 2. Register MessageHubs with the MessageRouter. Each MessageHub must have
+//! a unique ID and a callback to handle messages sent to its endpoints.
+//! 3. Open sessions from endpoints connected to MessageHubs to endpoints
+//! connected to other MessageHubs.
+//! 4. Send messages to endpoints using the MessageRouter API.
+//! 5. Close sessions when they are no longer needed.
+class MessageRouter {
+ public:
+ //! The callback used to register a MessageHub with the MessageRouter
+ class MessageHubCallback {
+ public:
+ virtual ~MessageHubCallback() = default;
+
+ //! Message processing callback. If this function returns true,
+ //! the MessageHub received the message and will deliver it to the
+ //! receiving endpoint, or close the session if an error occurs.
+ //! @see sendMessage
+ //! @param session The session that the message was sent on (this reference
+ //! is only valid for the duration of the callback)
+ //! @param sentBySessionInitiator Whether the message was sent by the
+ //! initiator of the session
+ //! @return true if the message was accepted for processing
+ virtual bool onMessageReceived(pw::UniquePtr<std::byte[]> &&data,
+ size_t length, uint32_t messageType,
+ uint32_t messagePermissions,
+ const Session &session,
+ bool sentBySessionInitiator) = 0;
+
+ //! Callback called when the session is closed
+ virtual void onSessionClosed(const Session &session) = 0;
+
+ //! Callback called to iterate over all endpoints connected to the
+ //! MessageHub. Underlying endpoint storage must not change during this
+ //! callback. If function returns true, the MessageHub can stop iterating
+ //! over future endpoints. This function should not call any MessageRouter
+ //! or MessageHub functions.
+ virtual void forEachEndpoint(
+ const pw::Function<bool(const EndpointInfo &)> &function) = 0;
+
+ //! @return The EndpointInfo for the given endpoint ID. This function should
+ //! not call any MessageRouter or MessageHub functions.
+ virtual std::optional<EndpointInfo> getEndpointInfo(
+ EndpointId endpointId) = 0;
+ };
+
+ //! The API returned when registering a MessageHub with the MessageRouter.
+ class MessageHub {
+ public:
+ //! Creates an empty MessageHub that is not usable, similar to a moved-from
+ //! MessageHub. Attempting to call any method on this object results in
+ //! undefined behavior.
+ MessageHub();
+
+ ~MessageHub() {
+ if (mRouter != nullptr) {
+ mRouter->unregisterMessageHub(mHubId);
+ }
+ }
+ // There can only be one live MessageHub instance for a given hub ID, so
+ // only move operations are supported.
+ MessageHub(const MessageHub &) = delete;
+ MessageHub &operator=(const MessageHub &) = delete;
+ MessageHub(MessageHub &&other);
+ MessageHub &operator=(MessageHub &&other);
+
+ //! Opens a session from an endpoint connected to the current MessageHub
+ //! to the listed MessageHub ID and endpoint ID
+ //! @return The session ID or SESSION_ID_INVALID if the session could
+ //! not be opened
+ SessionId openSession(EndpointId fromEndpointId,
+ MessageHubId toMessageHubId, EndpointId toEndpointId);
+
+ //! Closes the session with sessionId
+ //! @return true if the session was closed, false if the session was not
+ //! found
+ bool closeSession(SessionId sessionId);
+
+ //! Returns a session if it exists
+ //! @return The session or std::nullopt if the session was not found
+ std::optional<Session> getSessionWithId(SessionId sessionId);
+
+ //! Sends a message to the session specified by sessionId.
+ //! @see chreSendReliableMessageAsync. Sends the message in a reliable
+ //! manner if possible. If the message cannot be delivered, the session
+ //! is closed and subsequent calls to this function with the same sessionId
+ //! will return false.
+ //! @param data The data to send
+ //! @param length The length of the data to send
+ //! @param messageType The type of the message, a bit flagged value
+ //! @param messagePermissions The permissions of the message, a bit flagged
+ //! value
+ //! @param sessionId The session to send the message on
+ //! @return true if the message was sent, false if the message could not be
+ //! sent
+ bool sendMessage(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions,
+ SessionId sessionId);
+
+ //! @return The MessageHub ID of the currently connected MessageHub
+ MessageHubId getId();
+
+ private:
+ friend class MessageRouter;
+
+ MessageHub(MessageRouter &router, MessageHubId id);
+
+ //! The MessageRouter that this MessageHub is connected to
+ MessageRouter *mRouter;
+
+ //! The id of this message hub
+ MessageHubId mHubId;
+ };
+
+ //! Represents a MessageHub and its connected endpoints
+ struct MessageHubRecord {
+ MessageHubInfo info;
+ MessageHubCallback *callback;
+ };
+
+ MessageRouter() = delete;
+ MessageRouter(pw::Vector<MessageHubRecord> &messageHubs,
+ pw::Vector<Session> &sessions)
+ : mMessageHubs(messageHubs), mSessions(sessions) {}
+
+ //! Registers a MessageHub with the MessageRouter.
+ //! The provided name must be unique and not registered before and be a valid
+ //! C string. The data underlying name must outlive the MessageHub. The
+ //! callback must outlive the MessageHub. The ID must be unique and not
+ //! registered before. When the returned MessageHub is destroyed, it will
+ //! unregister itself from the MessageRouter.
+ //! @param name The name of the MessageHub
+ //! @param id The ID of the MessageHub
+ //! @param callback The callback to handle messages sent to the MessageHub
+ //! @return The MessageHub API or std::nullopt if the MessageHub could not be
+ //! registered
+ std::optional<MessageHub> registerMessageHub(const char *name,
+ MessageHubId id,
+ MessageHubCallback &callback);
+
+ //! Executes the function for each endpoint connected to this MessageHub.
+ //! If function returns true, the iteration will stop.
+ //! @return true if the MessageHub is found, false otherwise
+ bool forEachEndpointOfHub(
+ MessageHubId messageHubId,
+ const pw::Function<bool(const EndpointInfo &)> &function);
+
+ //! Executes the function for each endpoint connected to all Message Hubs.
+ //! The lock is held when calling the callback.
+ void forEachEndpoint(
+ const pw::Function<void(const MessageHubInfo &, const EndpointInfo &)>
+ &function);
+
+ //! @return The EndpointInfo for the given hub and endpoint IDs
+ std::optional<EndpointInfo> getEndpointInfo(MessageHubId messageHubId,
+ EndpointId endpointId);
+
+ //! Executes the function for each MessageHub connected to the MessageRouter.
+ //! If function returns true, the iteration will stop.
+ //! The lock is held when calling the callback.
+ void forEachMessageHub(
+ const pw::Function<bool(const MessageHubInfo &)> &function);
+
+ private:
+ //! Unregisters a MessageHub from the MessageRouter. This function will
+ //! close all sessions that were initiated by or connected to the MessageHub
+ //! and destroy the MessageHubRecord. This function will call the callback
+ //! for each session that was closed only for the other message hub in the
+ //! session.
+ //! @return true if the MessageHub was unregistered, false if the MessageHub
+ //! was not found.
+ bool unregisterMessageHub(MessageHubId fromMessageHubId);
+
+ //! Opens a session from an endpoint connected to the current MessageHub
+ //! to the listed MessageHub ID and endpoint ID
+ //! @return The session ID or SESSION_ID_INVALID if the session could not be
+ //! opened
+ SessionId openSession(MessageHubId fromMessageHubId,
+ EndpointId fromEndpointId, MessageHubId toMessageHubId,
+ EndpointId toEndpointId);
+
+ //! Closes the session with sessionId
+ //! @return true if the session was closed, false if the session was not
+ //! found
+ bool closeSession(MessageHubId fromMessageHubId, SessionId sessionId);
+
+ //! Returns a session if it exists
+ //! @return The session or std::nullopt if the session was not found
+ std::optional<Session> getSessionWithId(MessageHubId fromMessageHubId,
+ SessionId sessionId);
+
+ //! Sends a message to the session specified by sessionId.
+ //! @see chreSendReliableMessageAsync. Sends the message in a reliable
+ //! manner if possible. If the message cannot be delivered, the session
+ //! is closed and subsequent calls to this function with the same sessionId
+ //! will return false.
+ //! @see MessageHub::sendMessage
+ //! @return true if the message was sent, false if the message could not be
+ //! sent
+ bool sendMessage(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions,
+ SessionId sessionId, MessageHubId fromMessageHubId);
+
+ //! @return The MessageHubRecord for the given MessageHub ID
+ const MessageHubRecord *getMessageHubRecordLocked(MessageHubId messageHubId);
+
+ //! @return The index of the session if it exists
+ //! Requires the caller to hold the mutex
+ std::optional<size_t> findSessionIndexLocked(MessageHubId fromMessageHubId,
+ SessionId sessionId);
+
+ //! @return The callback for the given MessageHub ID or nullptr if not found
+ //! Requires the caller to hold the mutex
+ MessageHubCallback *getCallbackFromMessageHubId(MessageHubId messageHubId);
+
+ //! @return The callback for the given MessageHub ID or nullptr if not found
+ MessageHubCallback *getCallbackFromMessageHubIdLocked(
+ MessageHubId messageHubId);
+
+ //! @return true if the endpoint exists in the MessageHub with the given
+ //! callback
+ bool checkIfEndpointExists(MessageHubCallback *callback, EndpointId endpointId);
+
+ //! The mutex to protect MessageRouter state
+ Mutex mMutex;
+
+ //! The next available Session ID
+ SessionId mNextSessionId = 0;
+
+ //! The list of MessageHubs connected to the MessageRouter
+ pw::Vector<MessageHubRecord> &mMessageHubs;
+
+ //! The list of sessions connected to the MessageRouter
+ pw::Vector<Session> &mSessions;
+};
+
+//! Define the singleton instance of the MessageRouter
+typedef Singleton<MessageRouter> MessageRouterSingleton;
+
+//! Routes messages between MessageHubs
+template <size_t kMaxMessageHubs, size_t kMaxSessions>
+class MessageRouterWithStorage : public MessageRouter {
+ public:
+ MessageRouterWithStorage():
+ MessageRouter(mMessageHubs, mSessions) {}
+
+ private:
+ //! The list of MessageHubs connected to the MessageRouter
+ pw::Vector<MessageHubRecord, kMaxMessageHubs> mMessageHubs;
+
+ //! The list of sessions connected to the MessageRouter
+ pw::Vector<Session, kMaxSessions> mSessions;
+};
+
+} // namespace chre::message
+
+#endif // CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_H_
diff --git a/util/include/chre/util/system/message_router_callback_allocator.h b/util/include/chre/util/system/message_router_callback_allocator.h
new file mode 100644
index 0000000..e3aabd8
--- /dev/null
+++ b/util/include/chre/util/system/message_router_callback_allocator.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_H_
+#define CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_H_
+
+#include <pw_allocator/allocator.h>
+#include <pw_allocator/capability.h>
+#include <pw_allocator/unique_ptr.h>
+#include <pw_containers/vector.h>
+#include <pw_function/function.h>
+#include <cstddef>
+#include <optional>
+
+#include "chre/platform/mutex.h"
+
+namespace chre::message {
+
+//! An allocator for message free callbacks
+//! This allocator is used to store message free callbacks in a vector
+//! The allocator will call the free callback when the message is deallocated
+//! This is used to create pw::UniquePtrs for messages that have a free
+//! callback.
+//! @param Metadata The metadata type for the callback function
+template <typename Metadata>
+class MessageRouterCallbackAllocator : public pw::Allocator {
+ public:
+ static constexpr Capabilities kCapabilities = 0;
+
+ //! The callback used to free a message
+ using MessageFreeCallback = pw::Function<void(
+ std::byte *message, size_t length, const Metadata &metadata)>;
+
+ //! A record of a message and its free callback
+ struct FreeCallbackRecord {
+ std::byte *message;
+ Metadata metadata;
+ size_t messageSize;
+ };
+
+ MessageRouterCallbackAllocator(
+ MessageFreeCallback &&callback,
+ pw::Vector<FreeCallbackRecord> &freeCallbackRecords);
+
+ //! @see pw::Allocator::DoAllocate
+ virtual void *DoAllocate(Layout /* layout */) override;
+
+ //! @see pw::Allocator::DoDeallocate
+ virtual void DoDeallocate(void *ptr) override;
+
+ //! Creates a pw::UniquePtr for a message with a free callback.
+ //! The free callback will be called when the message is deallocated.
+ //! @return A pw::UniquePtr containing the message
+ [[nodiscard]] pw::UniquePtr<std::byte[]> MakeUniqueArrayWithCallback(
+ std::byte *ptr, size_t size, Metadata &&metadata);
+
+ private:
+ //! The callback used to free a message
+ MessageFreeCallback mCallback;
+
+ //! The mutex to protect mFreeCallbackRecords
+ Mutex mMutex;
+
+ //! The map of message pointers to free callbacks
+ pw::Vector<FreeCallbackRecord> &mFreeCallbackRecords;
+};
+
+} // namespace chre::message
+
+#include "chre/util/system/message_router_callback_allocator_impl.h"
+
+#endif // CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_H_
diff --git a/util/include/chre/util/system/message_router_callback_allocator_impl.h b/util/include/chre/util/system/message_router_callback_allocator_impl.h
new file mode 100644
index 0000000..fc27e90
--- /dev/null
+++ b/util/include/chre/util/system/message_router_callback_allocator_impl.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_IMPL_H_
+#define CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_IMPL_H_
+
+#include <pw_allocator/allocator.h>
+#include <pw_allocator/capability.h>
+#include <pw_allocator/unique_ptr.h>
+#include <pw_containers/vector.h>
+#include <pw_function/function.h>
+#include <cstddef>
+#include <optional>
+
+#include "chre/util/lock_guard.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router_callback_allocator.h"
+
+namespace chre::message {
+
+template <typename Metadata>
+MessageRouterCallbackAllocator<Metadata>::MessageRouterCallbackAllocator(
+ MessageFreeCallback &&callback,
+ pw::Vector<FreeCallbackRecord> &freeCallbackRecords)
+ : pw::Allocator(kCapabilities),
+ mCallback(std::move(callback)),
+ mFreeCallbackRecords(freeCallbackRecords) {}
+
+template <typename Metadata>
+void *MessageRouterCallbackAllocator<Metadata>::DoAllocate(
+ Layout /* layout */) {
+ return nullptr;
+}
+
+template <typename Metadata>
+void MessageRouterCallbackAllocator<Metadata>::DoDeallocate(void *ptr) {
+ std::optional<FreeCallbackRecord> freeCallbackRecord;
+ {
+ LockGuard<Mutex> lock(mMutex);
+ for (FreeCallbackRecord &record : mFreeCallbackRecords) {
+ if (record.message == ptr) {
+ freeCallbackRecord = std::move(record);
+ mFreeCallbackRecords.erase(&record);
+ break;
+ }
+ }
+ }
+
+ if (freeCallbackRecord.has_value()) {
+ mCallback(freeCallbackRecord->message, freeCallbackRecord->messageSize,
+ freeCallbackRecord->metadata);
+ }
+}
+
+template <typename Metadata>
+pw::UniquePtr<std::byte[]>
+MessageRouterCallbackAllocator<Metadata>::MakeUniqueArrayWithCallback(
+ std::byte *ptr, size_t size, Metadata &&metadata) {
+ {
+ LockGuard<Mutex> lock(mMutex);
+ if (mFreeCallbackRecords.full()) {
+ return pw::UniquePtr<std::byte[]>();
+ }
+
+ mFreeCallbackRecords.push_back(
+ {.message = ptr, .metadata = std::move(metadata), .messageSize = size});
+ }
+
+ return WrapUniqueArray(ptr, size);
+}
+
+} // namespace chre::message
+
+#endif // CHRE_UTIL_SYSTEM_MESSAGE_ROUTER_CALLBACK_ALLOCATOR_IMPL_H_
diff --git a/util/include/chre/util/synchronized_expandable_memory_pool.h b/util/include/chre/util/system/synchronized_expandable_memory_pool.h
similarity index 93%
rename from util/include/chre/util/synchronized_expandable_memory_pool.h
rename to util/include/chre/util/system/synchronized_expandable_memory_pool.h
index 72c8c62..3a5cd46 100644
--- a/util/include/chre/util/synchronized_expandable_memory_pool.h
+++ b/util/include/chre/util/system/synchronized_expandable_memory_pool.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
-#define CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
+#ifndef CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
+#define CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
#include "chre/platform/mutex.h"
#include "chre/util/fixed_size_vector.h"
@@ -124,6 +124,6 @@
} // namespace chre
-#include "chre/util/synchronized_expandable_memory_pool_impl.h" // IWYU pragma: export
+#include "chre/util/system/synchronized_expandable_memory_pool_impl.h" // IWYU pragma: export
-#endif // CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
+#endif // CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_H_
diff --git a/util/include/chre/util/synchronized_expandable_memory_pool_impl.h b/util/include/chre/util/system/synchronized_expandable_memory_pool_impl.h
similarity index 94%
rename from util/include/chre/util/synchronized_expandable_memory_pool_impl.h
rename to util/include/chre/util/system/synchronized_expandable_memory_pool_impl.h
index 31b9007..f5698b4 100644
--- a/util/include/chre/util/synchronized_expandable_memory_pool_impl.h
+++ b/util/include/chre/util/system/synchronized_expandable_memory_pool_impl.h
@@ -14,15 +14,15 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
-#define CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
+#ifndef CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
+#define CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
// IWYU pragma: private
#include <algorithm>
#include "chre/util/lock_guard.h"
#include "chre/util/memory_pool.h"
-#include "chre/util/synchronized_expandable_memory_pool.h"
+#include "chre/util/system/synchronized_expandable_memory_pool.h"
namespace chre {
@@ -147,4 +147,4 @@
}
} // namespace chre
-#endif // CHRE_UTIL_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
+#endif // CHRE_UTIL_SYSTEM_SYNCHRONIZED_EXPANDABLE_MEMORY_POOL_IMPL_H_
diff --git a/util/include/chre/util/synchronized_memory_pool.h b/util/include/chre/util/system/synchronized_memory_pool.h
similarity index 92%
rename from util/include/chre/util/synchronized_memory_pool.h
rename to util/include/chre/util/system/synchronized_memory_pool.h
index 7e5294d..85cdaf6 100644
--- a/util/include/chre/util/synchronized_memory_pool.h
+++ b/util/include/chre/util/system/synchronized_memory_pool.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_H_
-#define CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_H_
+#ifndef CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_H_
+#define CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_H_
#include "chre/platform/mutex.h"
#include "chre/util/memory_pool.h"
@@ -94,6 +94,6 @@
} // namespace chre
-#include "chre/util/synchronized_memory_pool_impl.h" // IWYU pragma: export
+#include "chre/util/system/synchronized_memory_pool_impl.h" // IWYU pragma: export
-#endif // CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_H_
+#endif // CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_H_
diff --git a/util/include/chre/util/synchronized_memory_pool_impl.h b/util/include/chre/util/system/synchronized_memory_pool_impl.h
similarity index 87%
rename from util/include/chre/util/synchronized_memory_pool_impl.h
rename to util/include/chre/util/system/synchronized_memory_pool_impl.h
index 6856500..6d78686 100644
--- a/util/include/chre/util/synchronized_memory_pool_impl.h
+++ b/util/include/chre/util/system/synchronized_memory_pool_impl.h
@@ -14,12 +14,12 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
-#define CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
+#ifndef CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
+#define CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
// IWYU pragma: private
#include "chre/util/lock_guard.h"
-#include "chre/util/synchronized_memory_pool.h"
+#include "chre/util/system/synchronized_memory_pool.h"
namespace chre {
@@ -53,4 +53,4 @@
} // namespace chre
-#endif // CHRE_UTIL_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
+#endif // CHRE_UTIL_SYSTEM_SYNCHRONIZED_MEMORY_POOL_IMPL_H_
diff --git a/util/include/chre/util/transaction_manager.h b/util/include/chre/util/system/transaction_manager.h
similarity index 97%
rename from util/include/chre/util/transaction_manager.h
rename to util/include/chre/util/system/transaction_manager.h
index 7fd4b0e..28656b2 100644
--- a/util/include/chre/util/transaction_manager.h
+++ b/util/include/chre/util/system/transaction_manager.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_TRANSACTION_MANAGER_H_
-#define CHRE_UTIL_TRANSACTION_MANAGER_H_
+#ifndef CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_H_
+#define CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_H_
#include <cstdint>
@@ -226,6 +226,6 @@
} // namespace chre
-#include "chre/util/transaction_manager_impl.h" // IWYU pragma: export
+#include "chre/util/system/transaction_manager_impl.h" // IWYU pragma: export
-#endif // CHRE_UTIL_TRANSACTION_MANAGER_H_
+#endif // CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_H_
diff --git a/util/include/chre/util/transaction_manager_impl.h b/util/include/chre/util/system/transaction_manager_impl.h
similarity index 97%
rename from util/include/chre/util/transaction_manager_impl.h
rename to util/include/chre/util/system/transaction_manager_impl.h
index 3aa5108..4d689b3 100644
--- a/util/include/chre/util/transaction_manager_impl.h
+++ b/util/include/chre/util/system/transaction_manager_impl.h
@@ -14,11 +14,11 @@
* limitations under the License.
*/
-#ifndef CHRE_UTIL_TRANSACTION_MANAGER_IMPL_H_
-#define CHRE_UTIL_TRANSACTION_MANAGER_IMPL_H_
+#ifndef CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_IMPL_H_
+#define CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_IMPL_H_
// IWYU pragma: private
-#include "chre/util/transaction_manager.h"
+#include "chre/util/system/transaction_manager.h"
#include "chre/core/event_loop_common.h"
#include "chre/platform/system_time.h"
@@ -230,4 +230,4 @@
} // namespace chre
-#endif // CHRE_UTIL_TRANSACTION_MANAGER_IMPL_H_
+#endif // CHRE_UTIL_SYSTEM_TRANSACTION_MANAGER_IMPL_H_
diff --git a/util/include/chre/util/throttle.h b/util/include/chre/util/throttle.h
index 5026afb..f6c54fd 100644
--- a/util/include/chre/util/throttle.h
+++ b/util/include/chre/util/throttle.h
@@ -17,10 +17,6 @@
#ifndef CHRE_UTIL_THROTTLE_H_
#define CHRE_UTIL_THROTTLE_H_
-#include "chre/util/optional.h"
-
-using ::chre::Optional;
-
/**
* Throttles an action to a given interval and maximum number of times.
* The action will be called at most maxCount in every interval.
@@ -30,20 +26,21 @@
* @param maxCount The maximum number of times to call the action
* @param getTime A function to get the current time
*/
-#define CHRE_THROTTLE(action, interval, maxCount, getTime) \
- do { \
- static uint32_t _count = 0; \
- static Optional<Nanoseconds> _lastCallTime; \
- Nanoseconds _now = getTime; \
- if (!_lastCallTime.has_value() || \
- _now - _lastCallTime.value() >= interval) { \
- _count = 0; \
- _lastCallTime = _now; \
- } \
- if (++_count > maxCount) { \
- break; \
- } \
- action; \
+#define CHRE_THROTTLE(action, interval, maxCount, getTime) \
+ do { \
+ static uint32_t _count = 0; \
+ static bool _hasLastCallTime = false; \
+ static Nanoseconds _lastCallTime; \
+ Nanoseconds _now = getTime; \
+ if (!_hasLastCallTime || _now - _lastCallTime >= interval) { \
+ _hasLastCallTime = true; \
+ _count = 0; \
+ _lastCallTime = _now; \
+ } \
+ if (++_count > maxCount) { \
+ break; \
+ } \
+ action; \
} while (0)
#endif // CHRE_UTIL_THROTTLE_H_
diff --git a/util/nanoapp/ble.cc b/util/nanoapp/ble.cc
index 8283ab6..7a6c0fc 100644
--- a/util/nanoapp/ble.cc
+++ b/util/nanoapp/ble.cc
@@ -19,6 +19,7 @@
namespace chre {
+using ble_constants::kBroadcasterAddress;
using ble_constants::kGoogleEddystoneUuid;
using ble_constants::kGoogleManufactureData;
using ble_constants::kGoogleManufactureDataLength;
@@ -26,6 +27,7 @@
using ble_constants::kGoogleNearbyFastpairUuid;
using ble_constants::kGoogleUuidDataLength;
using ble_constants::kGoogleUuidMask;
+using ble_constants::kNumBroadcasterFilters;
using ble_constants::kNumManufacturerDataFilters;
using ble_constants::kNumScanFilters;
using ble_constants::kRssiThreshold;
@@ -108,4 +110,25 @@
return true;
}
+bool createBleScanFilterForAdvertiser(
+ struct chreBleScanFilterV1_9 &filter,
+ chreBleBroadcasterAddressFilter *broadcasterFilters,
+ uint8_t numBroadcasterFilters) {
+ if (numBroadcasterFilters < kNumBroadcasterFilters) {
+ return false;
+ }
+
+ memcpy(&broadcasterFilters[0], kBroadcasterAddress,
+ sizeof(broadcasterFilters[0]));
+
+ memset(&filter, 0, sizeof(filter));
+ filter.rssiThreshold = kRssiThreshold;
+ filter.genericFilterCount = 0;
+ filter.genericFilters = nullptr;
+
+ filter.broadcasterAddressFilterCount = kNumBroadcasterFilters;
+ filter.broadcasterAddressFilters = broadcasterFilters;
+ return true;
+}
+
} // namespace chre
diff --git a/util/pigweed/rpc_server.cc b/util/pigweed/rpc_server.cc
index 42be93b..3fd6424 100644
--- a/util/pigweed/rpc_server.cc
+++ b/util/pigweed/rpc_server.cc
@@ -102,8 +102,9 @@
hostMessage->messageSize);
pw::Result<uint32_t> result = pw::rpc::ExtractChannelId(packet);
- if (result.status() != PW_STATUS_OK) {
- LOGE("Unable to extract channel ID from packet");
+ if (!result.status().ok()) {
+ LOGE("Unable to extract channel ID from packet: %" PRIu8,
+ static_cast<uint8_t>(result.status().code()));
return false;
}
@@ -124,13 +125,13 @@
mHostOutput.setHostEndpoint(hostMessage->hostEndpoint);
pw::Status status = mServer.OpenChannel(result.value(), mHostOutput);
if (status != pw::OkStatus() && status != pw::Status::AlreadyExists()) {
- LOGE("Failed to open channel");
+ LOGE("Failed to open channel: %" PRIu8, static_cast<uint8_t>(status.code()));
return false;
}
status = mServer.ProcessPacket(packet);
- if (status != pw::OkStatus()) {
- LOGE("Failed to process the packet");
+ if (!status.ok()) {
+ LOGE("Failed to process the packet: %" PRIu8, static_cast<uint8_t>(status.code()));
return false;
}
@@ -145,8 +146,9 @@
data->msgSize);
pw::Result<uint32_t> result = pw::rpc::ExtractChannelId(packet);
- if (result.status() != PW_STATUS_OK) {
- LOGE("Unable to extract channel ID from packet");
+ if (!result.status().ok()) {
+ LOGE("Unable to extract channel ID from packet: %" PRIu8,
+ static_cast<uint8_t>(result.status().code()));
return false;
}
@@ -159,13 +161,13 @@
mNanoappOutput.setClient(senderInstanceId);
pw::Status status = mServer.OpenChannel(result.value(), mNanoappOutput);
if (status != pw::OkStatus() && status != pw::Status::AlreadyExists()) {
- LOGE("Failed to open channel");
+ LOGE("Failed to open channel: %" PRIu8, static_cast<uint8_t>(status.code()));
return false;
}
status = mServer.ProcessPacket(packet);
- if (status != pw::OkStatus()) {
- LOGE("Failed to process the packet");
+ if (!status.ok()) {
+ LOGE("Failed to process the packet: %" PRIu8, static_cast<uint8_t>(status.code()));
return false;
}
@@ -196,9 +198,12 @@
auto info = static_cast<const struct chreNanoappInfo *>(eventData);
if (info->instanceId > kRpcNanoappMaxId) {
- LOGE("Invalid nanoapp Id 0x%08" PRIx32, info->instanceId);
- } else if (!mServer.CloseChannel(info->instanceId).ok()) {
- LOGE("Failed to close channel for nanoapp 0x%08" PRIx32, info->instanceId);
+ LOGE("Invalid nanoapp instance ID %" PRIu32, info->instanceId);
+ } else if (pw::Status status = mServer.CloseChannel(info->instanceId);
+ !status.ok()) {
+ LOGE("Failed to close channel for nanoapp with instance ID %"
+ PRIu32 ": %" PRIu8, info->instanceId,
+ static_cast<uint8_t>(status.code()));
}
}
diff --git a/util/system/message_router.cc b/util/system/message_router.cc
new file mode 100644
index 0000000..3582889
--- /dev/null
+++ b/util/system/message_router.cc
@@ -0,0 +1,422 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <inttypes.h>
+#include <cstring>
+#include <optional>
+#include <utility>
+
+#include "chre/platform/log.h"
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/lock_guard.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router.h"
+
+namespace chre::message {
+
+MessageRouter::MessageHub::MessageHub()
+ : mRouter(nullptr), mHubId(MESSAGE_HUB_ID_INVALID) {}
+
+MessageRouter::MessageHub::MessageHub(MessageRouter &router, MessageHubId id)
+ : mRouter(&router), mHubId(id) {}
+
+MessageRouter::MessageHub::MessageHub(MessageHub &&other)
+ : mRouter(other.mRouter), mHubId(other.mHubId) {
+ other.mRouter = nullptr;
+ other.mHubId = MESSAGE_HUB_ID_INVALID;
+}
+
+MessageRouter::MessageHub &MessageRouter::MessageHub::operator=(
+ MessageHub &&other) {
+ mRouter = other.mRouter;
+ mHubId = other.mHubId;
+ other.mRouter = nullptr;
+ other.mHubId = MESSAGE_HUB_ID_INVALID;
+ return *this;
+}
+
+SessionId MessageRouter::MessageHub::openSession(EndpointId fromEndpointId,
+ MessageHubId toMessageHubId,
+ EndpointId toEndpointId) {
+ return mRouter == nullptr
+ ? SESSION_ID_INVALID
+ : mRouter->openSession(mHubId, fromEndpointId, toMessageHubId,
+ toEndpointId);
+}
+
+bool MessageRouter::MessageHub::closeSession(SessionId sessionId) {
+ return mRouter == nullptr ? false : mRouter->closeSession(mHubId, sessionId);
+}
+
+std::optional<Session> MessageRouter::MessageHub::getSessionWithId(
+ SessionId sessionId) {
+ return mRouter == nullptr ? std::nullopt
+ : mRouter->getSessionWithId(mHubId, sessionId);
+}
+
+bool MessageRouter::MessageHub::sendMessage(pw::UniquePtr<std::byte[]> &&data,
+ size_t length, uint32_t messageType,
+ uint32_t messagePermissions,
+ SessionId sessionId) {
+ return mRouter == nullptr
+ ? false
+ : mRouter->sendMessage(std::move(data), length, messageType,
+ messagePermissions, sessionId, mHubId);
+}
+
+MessageHubId MessageRouter::MessageHub::getId() {
+ return mHubId;
+}
+
+std::optional<typename MessageRouter::MessageHub>
+MessageRouter::registerMessageHub(
+ const char *name, MessageHubId id,
+ MessageRouter::MessageRouter::MessageHubCallback &callback) {
+ LockGuard<Mutex> lock(mMutex);
+ if (mMessageHubs.full()) {
+ LOGE(
+ "Message hub '%s' not registered: maximum number of message hubs "
+ "reached",
+ name);
+ return std::nullopt;
+ }
+
+ for (MessageHubRecord &messageHub : mMessageHubs) {
+ if (std::strcmp(messageHub.info.name, name) == 0 ||
+ messageHub.info.id == id) {
+ LOGE(
+ "Message hub '%s' not registered: hub with same name or ID already "
+ "exists",
+ name);
+ return std::nullopt;
+ }
+ }
+
+ MessageHubRecord messageHubRecord = {
+ .info = {.id = id, .name = name},
+ .callback = &callback,
+ };
+ mMessageHubs.push_back(std::move(messageHubRecord));
+ return MessageHub(*this, id);
+}
+
+bool MessageRouter::forEachEndpointOfHub(
+ MessageHubId messageHubId,
+ const pw::Function<bool(const EndpointInfo &)> &function) {
+ MessageRouter::MessageHubCallback *callback =
+ getCallbackFromMessageHubId(messageHubId);
+ if (callback == nullptr) {
+ LOGE("Failed to find message hub with ID %" PRIu64, messageHubId);
+ return false;
+ }
+
+ callback->forEachEndpoint(function);
+ return true;
+}
+
+void MessageRouter::forEachEndpoint(
+ const pw::Function<void(const MessageHubInfo &, const EndpointInfo &)>
+ &function) {
+ LockGuard<Mutex> lock(mMutex);
+
+ struct Context {
+ decltype(function) function;
+ MessageHubInfo &messageHubInfo;
+ };
+ for (MessageHubRecord &messageHubRecord : mMessageHubs) {
+ Context context = {
+ .function = function,
+ .messageHubInfo = messageHubRecord.info,
+ };
+
+ messageHubRecord.callback->forEachEndpoint(
+ [&context](const EndpointInfo &endpointInfo) {
+ context.function(context.messageHubInfo, endpointInfo);
+ return false;
+ });
+ }
+}
+
+std::optional<EndpointInfo> MessageRouter::getEndpointInfo(
+ MessageHubId messageHubId, EndpointId endpointId) {
+ MessageRouter::MessageHubCallback *callback =
+ getCallbackFromMessageHubId(messageHubId);
+ if (callback == nullptr) {
+ LOGE("Failed to get endpoint info for message hub with ID %" PRIu64
+ " and endpoint ID %" PRIu64 ": hub not found",
+ messageHubId, endpointId);
+ return std::nullopt;
+ }
+
+ return callback->getEndpointInfo(endpointId);
+}
+
+void MessageRouter::forEachMessageHub(
+ const pw::Function<bool(const MessageHubInfo &)> &function) {
+ LockGuard<Mutex> lock(mMutex);
+ for (MessageHubRecord &messageHubRecord : mMessageHubs) {
+ function(messageHubRecord.info);
+ }
+}
+
+bool MessageRouter::unregisterMessageHub(MessageHubId fromMessageHubId) {
+ DynamicVector<std::pair<MessageHubCallback *, Session>> sessionsToDestroy;
+
+ {
+ LockGuard<Mutex> lock(mMutex);
+
+ bool success = false;
+ for (MessageHubRecord &messageHubRecord : mMessageHubs) {
+ if (messageHubRecord.info.id == fromMessageHubId) {
+ mMessageHubs.erase(&messageHubRecord);
+ success = true;
+ break;
+ }
+ }
+ if (!success) {
+ return false;
+ }
+
+ for (size_t i = 0; i < mSessions.size();) {
+ Session &session = mSessions[i];
+ bool initiatorIsFromHub =
+ session.initiator.messageHubId == fromMessageHubId;
+ bool peerIsFromHub = session.peer.messageHubId == fromMessageHubId;
+
+ if (initiatorIsFromHub || peerIsFromHub) {
+ MessageHubCallback *callback = getCallbackFromMessageHubIdLocked(
+ initiatorIsFromHub ? session.peer.messageHubId
+ : session.initiator.messageHubId);
+ sessionsToDestroy.push_back(std::make_pair(callback, session));
+ mSessions.erase(&mSessions[i]);
+ } else {
+ ++i;
+ }
+ }
+ }
+
+ for (auto [callback, session] : sessionsToDestroy) {
+ if (callback != nullptr) {
+ callback->onSessionClosed(session);
+ }
+ }
+ return true;
+}
+
+SessionId MessageRouter::openSession(MessageHubId fromMessageHubId,
+ EndpointId fromEndpointId,
+ MessageHubId toMessageHubId,
+ EndpointId toEndpointId) {
+ if (fromMessageHubId == toMessageHubId) {
+ LOGE(
+ "Failed to open session: initiator and peer message hubs are the "
+ "same");
+ return SESSION_ID_INVALID;
+ }
+
+ MessageRouter::MessageHubCallback *initiatorCallback =
+ getCallbackFromMessageHubId(fromMessageHubId);
+ MessageRouter::MessageHubCallback *peerCallback =
+ getCallbackFromMessageHubId(toMessageHubId);
+ if (initiatorCallback == nullptr || peerCallback == nullptr) {
+ LOGE("Failed to open session: initiator or peer message hub not found");
+ return SESSION_ID_INVALID;
+ }
+
+ if (!checkIfEndpointExists(initiatorCallback, fromEndpointId)) {
+ LOGE("Failed to open session: endpoint with ID %" PRIu64
+ " not found in message hub with ID %" PRIu64,
+ fromEndpointId, fromMessageHubId);
+ return SESSION_ID_INVALID;
+ }
+
+ if (!checkIfEndpointExists(peerCallback, toEndpointId)) {
+ LOGE("Failed to open session: endpoint with ID %" PRIu64
+ " not found in message hub with ID %" PRIu64,
+ toEndpointId, toMessageHubId);
+ return SESSION_ID_INVALID;
+ }
+
+ {
+ LockGuard<Mutex> lock(mMutex);
+ if (mSessions.full()) {
+ LOGE("Failed to open session: maximum number of sessions reached");
+ return SESSION_ID_INVALID;
+ }
+
+ Session insertSession = {
+ .sessionId = mNextSessionId,
+ .initiator = {.messageHubId = fromMessageHubId,
+ .endpointId = fromEndpointId},
+ .peer = {.messageHubId = toMessageHubId, .endpointId = toEndpointId},
+ };
+
+ for (Session &session : mSessions) {
+ if (session.isEquivalent(insertSession)) {
+ LOGD("Session with ID %" PRIu16 " already exists", session.sessionId);
+ return session.sessionId;
+ }
+ }
+
+ mSessions.push_back(std::move(insertSession));
+ return mNextSessionId++;
+ }
+}
+
+bool MessageRouter::closeSession(MessageHubId fromMessageHubId,
+ SessionId sessionId) {
+ Session session;
+ MessageRouter::MessageHubCallback *initiatorCallback = nullptr;
+ MessageRouter::MessageHubCallback *peerCallback = nullptr;
+ {
+ LockGuard<Mutex> lock(mMutex);
+
+ std::optional<size_t> index =
+ findSessionIndexLocked(fromMessageHubId, sessionId);
+ if (!index.has_value()) {
+ LOGE("Failed to close session with ID %" PRIu16 ": session not found",
+ sessionId);
+ return false;
+ }
+
+ session = mSessions[*index];
+ initiatorCallback =
+ getCallbackFromMessageHubIdLocked(session.initiator.messageHubId);
+ peerCallback = getCallbackFromMessageHubIdLocked(session.peer.messageHubId);
+ mSessions.erase(&mSessions[*index]);
+ }
+
+ if (initiatorCallback != nullptr) {
+ initiatorCallback->onSessionClosed(session);
+ }
+ if (peerCallback != nullptr) {
+ peerCallback->onSessionClosed(session);
+ }
+ return true;
+}
+
+std::optional<Session> MessageRouter::getSessionWithId(
+ MessageHubId fromMessageHubId, SessionId sessionId) {
+ LockGuard<Mutex> lock(mMutex);
+
+ std::optional<size_t> index =
+ findSessionIndexLocked(fromMessageHubId, sessionId);
+ return index.has_value() ? std::optional<Session>(mSessions[*index])
+ : std::nullopt;
+}
+
+bool MessageRouter::sendMessage(pw::UniquePtr<std::byte[]> &&data,
+ size_t length, uint32_t messageType,
+ uint32_t messagePermissions,
+ SessionId sessionId,
+ MessageHubId fromMessageHubId) {
+ MessageRouter::MessageHubCallback *receiverCallback = nullptr;
+ Session session;
+ {
+ LockGuard<Mutex> lock(mMutex);
+
+ std::optional<size_t> index =
+ findSessionIndexLocked(fromMessageHubId, sessionId);
+ if (!index.has_value()) {
+ LOGE("Failed to send message: session with ID %" PRIu16 " not found",
+ sessionId);
+ return false;
+ }
+
+ session = mSessions[*index];
+ receiverCallback = getCallbackFromMessageHubIdLocked(
+ session.initiator.messageHubId == fromMessageHubId
+ ? session.peer.messageHubId
+ : session.initiator.messageHubId);
+ }
+
+ bool success = false;
+ if (receiverCallback != nullptr) {
+ success = receiverCallback->onMessageReceived(
+ std::move(data), length, messageType, messagePermissions, session,
+ session.initiator.messageHubId == fromMessageHubId);
+ }
+
+ if (!success) {
+ closeSession(fromMessageHubId, sessionId);
+ }
+ return success;
+}
+
+const MessageRouter::MessageHubRecord *MessageRouter::getMessageHubRecordLocked(
+ MessageHubId messageHubId) {
+ for (MessageHubRecord &messageHubRecord : mMessageHubs) {
+ if (messageHubRecord.info.id == messageHubId) {
+ return &messageHubRecord;
+ }
+ }
+ return nullptr;
+}
+
+std::optional<size_t> MessageRouter::findSessionIndexLocked(
+ MessageHubId fromMessageHubId, SessionId sessionId) {
+ for (size_t i = 0; i < mSessions.size(); ++i) {
+ if (mSessions[i].sessionId == sessionId) {
+ if (mSessions[i].initiator.messageHubId == fromMessageHubId ||
+ mSessions[i].peer.messageHubId == fromMessageHubId) {
+ return i;
+ }
+
+ LOGE("Hub mismatch for session with ID %" PRIu16
+ ": requesting hub ID %" PRIu64
+ " but session is between hubs %" PRIu64 " and %" PRIu64,
+ sessionId, fromMessageHubId, mSessions[i].initiator.messageHubId,
+ mSessions[i].peer.messageHubId);
+ break;
+ }
+ }
+ return std::nullopt;
+}
+
+MessageRouter::MessageHubCallback *MessageRouter::getCallbackFromMessageHubId(
+ MessageHubId messageHubId) {
+ LockGuard<Mutex> lock(mMutex);
+ return getCallbackFromMessageHubIdLocked(messageHubId);
+}
+
+MessageRouter::MessageHubCallback *
+MessageRouter::getCallbackFromMessageHubIdLocked(MessageHubId messageHubId) {
+ const MessageHubRecord *messageHubRecord =
+ getMessageHubRecordLocked(messageHubId);
+ return messageHubRecord == nullptr ? nullptr : messageHubRecord->callback;
+}
+
+bool MessageRouter::checkIfEndpointExists(
+ MessageRouter::MessageHubCallback *callback, EndpointId endpointId) {
+ struct EndpointContext {
+ EndpointId endpointId;
+ bool foundEndpoint = false;
+ };
+ EndpointContext context = {
+ .endpointId = endpointId,
+ };
+
+ callback->forEachEndpoint([&context](const EndpointInfo &endpointInfo) {
+ if (context.endpointId == endpointInfo.id) {
+ context.foundEndpoint = true;
+ return true;
+ }
+ return false;
+ });
+ return context.foundEndpoint;
+}
+
+} // namespace chre::message
diff --git a/util/tests/array_queue_test.cc b/util/tests/array_queue_test.cc
index bc55d19..ed8e2c6 100644
--- a/util/tests/array_queue_test.cc
+++ b/util/tests/array_queue_test.cc
@@ -36,17 +36,20 @@
public:
FakeElement() {
constructor_count++;
- };
+ }
+
FakeElement(int i) {
val_ = i;
constructor_count++;
- };
+ }
+
~FakeElement() {
total_destructor_count++;
if (val_ >= 0 && val_ < kMaxTestCapacity) {
destructor_count[val_]++;
}
- };
+ }
+
void setValue(int i) {
val_ = i;
}
diff --git a/util/tests/atomic_spsc_queue_test.cc b/util/tests/atomic_spsc_queue_test.cc
index 2915af2..8ebb27a 100644
--- a/util/tests/atomic_spsc_queue_test.cc
+++ b/util/tests/atomic_spsc_queue_test.cc
@@ -37,17 +37,20 @@
public:
FakeElement() {
constructor_count++;
- };
+ }
+
FakeElement(int i) {
val_ = i;
constructor_count++;
- };
+ }
+
~FakeElement() {
total_destructor_count++;
if (val_ >= 0 && val_ < kMaxTestCapacity) {
destructor_count[val_]++;
}
- };
+ }
+
void setValue(int i) {
val_ = i;
}
diff --git a/util/tests/blocking_queue_test.cc b/util/tests/blocking_queue_test.cc
index a05f657..461a7bc 100644
--- a/util/tests/blocking_queue_test.cc
+++ b/util/tests/blocking_queue_test.cc
@@ -17,7 +17,7 @@
#include "gtest/gtest.h"
#include "chre/util/blocking_segmented_queue.h"
-#include "chre/util/fixed_size_blocking_queue.h"
+#include "chre/util/system/fixed_size_blocking_queue.h"
#include "chre/util/unique_ptr.h"
using chre::BlockingSegmentedQueue;
diff --git a/util/tests/dynamic_vector_test.cc b/util/tests/dynamic_vector_test.cc
index e69bd4c..80befe1 100644
--- a/util/tests/dynamic_vector_test.cc
+++ b/util/tests/dynamic_vector_test.cc
@@ -38,7 +38,8 @@
if (mValue >= 0) {
gDestructorCount[mValue]++;
}
- };
+ }
+
void setValue(int value) {
mValue = value;
}
diff --git a/util/tests/fixed_size_vector_test.cc b/util/tests/fixed_size_vector_test.cc
index 6bdffc2..4145658 100644
--- a/util/tests/fixed_size_vector_test.cc
+++ b/util/tests/fixed_size_vector_test.cc
@@ -30,7 +30,8 @@
if (mValue >= 0) {
destructor_count[mValue]++;
}
- };
+ }
+
void setValue(int value) {
mValue = value;
}
diff --git a/util/tests/message_router_test.cc b/util/tests/message_router_test.cc
new file mode 100644
index 0000000..8c6f875
--- /dev/null
+++ b/util/tests/message_router_test.cc
@@ -0,0 +1,1175 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <pw_allocator/allocator.h>
+#include <pw_allocator/capability.h>
+#include <pw_allocator/unique_ptr.h>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <utility>
+
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/system/message_common.h"
+#include "chre/util/system/message_router.h"
+#include "chre/util/system/message_router_callback_allocator.h"
+#include "chre_api/chre.h"
+#include "gtest/gtest.h"
+
+namespace chre::message {
+namespace {
+
+constexpr size_t kMaxMessageHubs = 3;
+constexpr size_t kMaxSessions = 10;
+constexpr size_t kMaxFreeCallbackRecords = kMaxSessions * 2;
+constexpr size_t kNumEndpoints = 3;
+
+const EndpointInfo kEndpointInfos[kNumEndpoints] = {
+ EndpointInfo(/* id= */ 1, /* name= */ "endpoint1", /* version= */ 1,
+ EndpointType::NANOAPP, CHRE_MESSAGE_PERMISSION_NONE),
+ EndpointInfo(/* id= */ 2, /* name= */ "endpoint2", /* version= */ 10,
+ EndpointType::HOST_NATIVE, CHRE_MESSAGE_PERMISSION_BLE),
+ EndpointInfo(/* id= */ 3, /* name= */ "endpoint3", /* version= */ 100,
+ EndpointType::GENERIC, CHRE_MESSAGE_PERMISSION_AUDIO)};
+
+class TestAllocator : public pw::Allocator {
+ public:
+ static constexpr Capabilities kCapabilities = 0;
+
+ TestAllocator() : pw::Allocator(kCapabilities) {}
+
+ virtual void *DoAllocate(Layout layout) override {
+ if (layout.alignment() > alignof(std::max_align_t)) {
+ void *ptr;
+ return posix_memalign(&ptr, layout.alignment(), layout.size()) == 0
+ ? ptr
+ : nullptr;
+ } else {
+ return malloc(layout.size());
+ }
+ }
+
+ virtual void DoDeallocate(void *ptr) override {
+ free(ptr);
+ }
+};
+
+class MessageRouterTest : public ::testing::Test {
+ protected:
+ void SetUp() override {}
+
+ TestAllocator mAllocator;
+};
+
+//! Base class for MessageHubCallbacks used in tests
+class MessageHubCallbackBase : public MessageRouter::MessageHubCallback {
+ public:
+ void forEachEndpoint(
+ const pw::Function<bool(const EndpointInfo &)> &function) override {
+ for (const EndpointInfo &endpointInfo : kEndpointInfos) {
+ if (function(endpointInfo)) {
+ return;
+ }
+ }
+ }
+
+ std::optional<EndpointInfo> getEndpointInfo(EndpointId endpointId) override {
+ for (const EndpointInfo &endpointInfo : kEndpointInfos) {
+ if (endpointInfo.id == endpointId) {
+ return endpointInfo;
+ }
+ }
+ return std::nullopt;
+ }
+};
+
+//! MessageHubCallback that stores the data passed to onMessageReceived and
+//! onSessionClosed
+class MessageHubCallbackStoreData : public MessageHubCallbackBase {
+ public:
+ MessageHubCallbackStoreData(Message *message, Session *session)
+ : mMessage(message), mSession(session) {}
+
+ bool onMessageReceived(pw::UniquePtr<std::byte[]> &&data, size_t length,
+ uint32_t messageType, uint32_t messagePermissions,
+ const Session &session,
+ bool sentBySessionInitiator) override {
+ if (mMessage != nullptr) {
+ mMessage->sender = sentBySessionInitiator ? session.initiator
+ : session.peer;
+ mMessage->recipient =
+ sentBySessionInitiator ? session.peer : session.initiator;
+ mMessage->sessionId = session.sessionId;
+ mMessage->data = std::move(data);
+ mMessage->length = length;
+ mMessage->messageType = messageType;
+ mMessage->messagePermissions = messagePermissions;
+ }
+ return true;
+ }
+
+ void onSessionClosed(const Session &session) override {
+ if (mSession != nullptr) {
+ *mSession = session;
+ }
+ }
+
+ private:
+ Message *mMessage;
+ Session *mSession;
+};
+
+//! MessageHubCallback that always fails to process messages
+class MessageHubCallbackAlwaysFails : public MessageHubCallbackBase {
+ public:
+ MessageHubCallbackAlwaysFails(bool *wasMessageReceivedCalled,
+ bool *wasSessionClosedCalled)
+ : mWasMessageReceivedCalled(wasMessageReceivedCalled),
+ mWasSessionClosedCalled(wasSessionClosedCalled) {}
+
+ bool onMessageReceived(pw::UniquePtr<std::byte[]> && /* data */,
+ size_t /* length */, uint32_t /* messageType */,
+ uint32_t /* messagePermissions */,
+ const Session & /* session */,
+ bool /* sentBySessionInitiator */) override {
+ if (mWasMessageReceivedCalled != nullptr) {
+ *mWasMessageReceivedCalled = true;
+ }
+ return false;
+ }
+
+ void onSessionClosed(const Session & /* session */) override {
+ if (mWasSessionClosedCalled != nullptr) {
+ *mWasSessionClosedCalled = true;
+ }
+ }
+
+ private:
+ bool *mWasMessageReceivedCalled;
+ bool *mWasSessionClosedCalled;
+};
+
+//! MessageHubCallback that calls MessageHub APIs during callbacks
+class MessageHubCallbackCallsMessageHubApisDuringCallback
+ : public MessageHubCallbackBase {
+ public:
+ bool onMessageReceived(pw::UniquePtr<std::byte[]> && /* data */,
+ size_t /* length */, uint32_t /* messageType */,
+ uint32_t /* messagePermissions */,
+ const Session & /* session */,
+ bool /* sentBySessionInitiator */) override {
+ if (mMessageHub != nullptr) {
+ // Call a function that locks the MessageRouter mutex
+ mMessageHub->openSession(kEndpointInfos[0].id, mMessageHub->getId(),
+ kEndpointInfos[1].id);
+ }
+ return true;
+ }
+
+ void onSessionClosed(const Session & /* session */) override {
+ if (mMessageHub != nullptr) {
+ // Call a function that locks the MessageRouter mutex
+ mMessageHub->openSession(kEndpointInfos[0].id, mMessageHub->getId(),
+ kEndpointInfos[1].id);
+ }
+ }
+
+ void setMessageHub(MessageRouter::MessageHub *messageHub) {
+ mMessageHub = messageHub;
+ }
+
+ private:
+ MessageRouter::MessageHub *mMessageHub = nullptr;
+};
+
+TEST_F(MessageRouterTest, RegisterMessageHubNameIsUnique) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub1 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub1.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_FALSE(messageHub3.has_value());
+}
+
+TEST_F(MessageRouterTest, RegisterMessageHubIdIsUnique) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub1 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub1.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 1, callback);
+ EXPECT_FALSE(messageHub3.has_value());
+}
+
+TEST_F(MessageRouterTest, RegisterMessageHubGetListOfHubs) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub1 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub1.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ DynamicVector<MessageHubInfo> messageHubs;
+ router.forEachMessageHub(
+ [&messageHubs](const MessageHubInfo &messageHubInfo) {
+ messageHubs.push_back(messageHubInfo);
+ return false;
+ });
+ EXPECT_EQ(messageHubs.size(), 3);
+ EXPECT_EQ(messageHubs[0].name, "hub1");
+ EXPECT_EQ(messageHubs[1].name, "hub2");
+ EXPECT_EQ(messageHubs[2].name, "hub3");
+ EXPECT_EQ(messageHubs[0].id, 1);
+ EXPECT_EQ(messageHubs[1].id, 2);
+ EXPECT_EQ(messageHubs[2].id, 3);
+ EXPECT_EQ(messageHubs[0].id, messageHub1->getId());
+ EXPECT_EQ(messageHubs[1].id, messageHub2->getId());
+ EXPECT_EQ(messageHubs[2].id, messageHub3->getId());
+}
+
+TEST_F(MessageRouterTest, RegisterMessageHubGetListOfHubsWithUnregister) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub1 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub1.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ DynamicVector<MessageHubInfo> messageHubs;
+ router.forEachMessageHub(
+ [&messageHubs](const MessageHubInfo &messageHubInfo) {
+ messageHubs.push_back(messageHubInfo);
+ return false;
+ });
+ EXPECT_EQ(messageHubs.size(), 3);
+ EXPECT_EQ(messageHubs[0].name, "hub1");
+ EXPECT_EQ(messageHubs[1].name, "hub2");
+ EXPECT_EQ(messageHubs[2].name, "hub3");
+ EXPECT_EQ(messageHubs[0].id, 1);
+ EXPECT_EQ(messageHubs[1].id, 2);
+ EXPECT_EQ(messageHubs[2].id, 3);
+ EXPECT_EQ(messageHubs[0].id, messageHub1->getId());
+ EXPECT_EQ(messageHubs[1].id, messageHub2->getId());
+ EXPECT_EQ(messageHubs[2].id, messageHub3->getId());
+
+ // Clear messageHubs and reset messageHub2
+ messageHubs.clear();
+ messageHub2.reset();
+
+ router.forEachMessageHub(
+ [&messageHubs](const MessageHubInfo &messageHubInfo) {
+ messageHubs.push_back(messageHubInfo);
+ return false;
+ });
+ EXPECT_EQ(messageHubs.size(), 2);
+ EXPECT_EQ(messageHubs[0].name, "hub1");
+ EXPECT_EQ(messageHubs[1].name, "hub3");
+ EXPECT_EQ(messageHubs[0].id, 1);
+ EXPECT_EQ(messageHubs[1].id, 3);
+ EXPECT_EQ(messageHubs[0].id, messageHub1->getId());
+ EXPECT_EQ(messageHubs[1].id, messageHub3->getId());
+}
+
+TEST_F(MessageRouterTest, RegisterMessageHubTooManyFails) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ static_assert(kMaxMessageHubs == 3);
+ constexpr const char *kNames[3] = {"hub1", "hub2", "hub3"};
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ MessageRouter::MessageHub messageHubs[kMaxMessageHubs];
+ for (size_t i = 0; i < kMaxMessageHubs; ++i) {
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub(kNames[i], /* id= */ i, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ messageHubs[i] = std::move(*messageHub);
+ }
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("shouldfail", /* id= */ kMaxMessageHubs * 2,
+ callback);
+ EXPECT_FALSE(messageHub.has_value());
+}
+
+TEST_F(MessageRouterTest, GetEndpointInfo) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub1 =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub1.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ for (size_t i = 0; i < kNumEndpoints; ++i) {
+ EXPECT_EQ(
+ router.getEndpointInfo(messageHub1->getId(), kEndpointInfos[i].id),
+ kEndpointInfos[i]);
+ EXPECT_EQ(
+ router.getEndpointInfo(messageHub2->getId(), kEndpointInfos[i].id),
+ kEndpointInfos[i]);
+ EXPECT_EQ(
+ router.getEndpointInfo(messageHub3->getId(), kEndpointInfos[i].id),
+ kEndpointInfos[i]);
+ }
+}
+
+TEST_F(MessageRouterTest, RegisterSessionTwoDifferentMessageHubs) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ &sessionFromCallback2);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Get session from messageHub and compare it with messageHub2
+ std::optional<Session> sessionAfterRegistering =
+ messageHub->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ EXPECT_EQ(sessionAfterRegistering->sessionId, sessionId);
+ EXPECT_EQ(sessionAfterRegistering->initiator.messageHubId,
+ messageHub->getId());
+ EXPECT_EQ(sessionAfterRegistering->initiator.endpointId,
+ kEndpointInfos[0].id);
+ EXPECT_EQ(sessionAfterRegistering->peer.messageHubId, messageHub2->getId());
+ EXPECT_EQ(sessionAfterRegistering->peer.endpointId, kEndpointInfos[1].id);
+ std::optional<Session> sessionAfterRegistering2 =
+ messageHub2->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Close the session and verify it is closed on both message hubs
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback1);
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback2);
+ EXPECT_TRUE(messageHub->closeSession(sessionId));
+ EXPECT_EQ(*sessionAfterRegistering, sessionFromCallback1);
+ EXPECT_EQ(*sessionAfterRegistering, sessionFromCallback2);
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId).has_value());
+ EXPECT_FALSE(messageHub2->getSessionWithId(sessionId).has_value());
+}
+
+TEST_F(MessageRouterTest, UnregisterMessageHubCausesSessionClosed) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ &sessionFromCallback2);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Get session from messageHub and compare it with messageHub2
+ std::optional<Session> sessionAfterRegistering =
+ messageHub->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ EXPECT_EQ(sessionAfterRegistering->sessionId, sessionId);
+ EXPECT_EQ(sessionAfterRegistering->initiator.messageHubId,
+ messageHub->getId());
+ EXPECT_EQ(sessionAfterRegistering->initiator.endpointId,
+ kEndpointInfos[0].id);
+ EXPECT_EQ(sessionAfterRegistering->peer.messageHubId, messageHub2->getId());
+ EXPECT_EQ(sessionAfterRegistering->peer.endpointId, kEndpointInfos[1].id);
+ std::optional<Session> sessionAfterRegistering2 =
+ messageHub2->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Close the session and verify it is closed on the other hub
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback1);
+ messageHub2.reset();
+ EXPECT_EQ(*sessionAfterRegistering, sessionFromCallback1);
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId).has_value());
+}
+
+TEST_F(MessageRouterTest, RegisterSessionSameMessageHubInvalid) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ &sessionFromCallback2);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ // Open session from messageHub:2 to messageHub:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[1].id, messageHub->getId(), kEndpointInfos[1].id);
+ EXPECT_EQ(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub:1 to messageHub:3
+ sessionId = messageHub->openSession(kEndpointInfos[0].id, messageHub->getId(),
+ kEndpointInfos[2].id);
+ EXPECT_EQ(sessionId, SESSION_ID_INVALID);
+}
+
+TEST_F(MessageRouterTest, RegisterSessionDifferentMessageHubsSameEndpoints) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ &sessionFromCallback2);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ // Open session from messageHub:1 to messageHub:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+}
+
+TEST_F(MessageRouterTest,
+ RegisterSessionTwoDifferentMessageHubsInvalidEndpoint) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ /* session= */ nullptr);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+
+ // Open session from messageHub with other non-registered endpoint - not
+ // valid
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), /* toEndpointId= */ 10);
+ EXPECT_EQ(sessionId, SESSION_ID_INVALID);
+}
+
+TEST_F(MessageRouterTest, ThirdMessageHubTriesToFindOthersSession) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ Session sessionFromCallback3;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ &sessionFromCallback2);
+ MessageHubCallbackStoreData callback3(/* message= */ nullptr,
+ &sessionFromCallback3);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Get session from messageHub and compare it with messageHub2
+ std::optional<Session> sessionAfterRegistering =
+ messageHub->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ EXPECT_EQ(sessionAfterRegistering->sessionId, sessionId);
+ EXPECT_EQ(sessionAfterRegistering->initiator.messageHubId,
+ messageHub->getId());
+ EXPECT_EQ(sessionAfterRegistering->initiator.endpointId,
+ kEndpointInfos[0].id);
+ EXPECT_EQ(sessionAfterRegistering->peer.messageHubId, messageHub2->getId());
+ EXPECT_EQ(sessionAfterRegistering->peer.endpointId, kEndpointInfos[1].id);
+ std::optional<Session> sessionAfterRegistering2 =
+ messageHub2->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Third message hub tries to find the session - not found
+ EXPECT_FALSE(messageHub3->getSessionWithId(sessionId).has_value());
+ // Third message hub tries to close the session - not found
+ EXPECT_FALSE(messageHub3->closeSession(sessionId));
+
+ // Get session from messageHub and compare it with messageHub2 again
+ sessionAfterRegistering = messageHub->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ EXPECT_EQ(sessionAfterRegistering->sessionId, sessionId);
+ EXPECT_EQ(sessionAfterRegistering->initiator.messageHubId,
+ messageHub->getId());
+ EXPECT_EQ(sessionAfterRegistering->initiator.endpointId,
+ kEndpointInfos[0].id);
+ EXPECT_EQ(sessionAfterRegistering->peer.messageHubId, messageHub2->getId());
+ EXPECT_EQ(sessionAfterRegistering->peer.endpointId, kEndpointInfos[1].id);
+ sessionAfterRegistering2 = messageHub2->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Close the session and verify it is closed on both message hubs
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback1);
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback2);
+ EXPECT_TRUE(messageHub->closeSession(sessionId));
+ EXPECT_EQ(*sessionAfterRegistering, sessionFromCallback1);
+ EXPECT_EQ(*sessionAfterRegistering, sessionFromCallback2);
+ EXPECT_NE(*sessionAfterRegistering, sessionFromCallback3);
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId).has_value());
+ EXPECT_FALSE(messageHub2->getSessionWithId(sessionId).has_value());
+}
+
+TEST_F(MessageRouterTest, ThreeMessageHubsAndThreeSessions) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ MessageHubCallbackStoreData callback2(/* message= */ nullptr,
+ /* session= */ nullptr);
+ MessageHubCallbackStoreData callback3(/* message= */ nullptr,
+ /* session= */ nullptr);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Get sessions and compare
+ // Find session: MessageHub1:1 -> MessageHub2:2
+ std::optional<Session> sessionAfterRegistering =
+ messageHub->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ std::optional<Session> sessionAfterRegistering2 =
+ messageHub2->getSessionWithId(sessionId);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_FALSE(messageHub3->getSessionWithId(sessionId).has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Find session: MessageHub2:2 -> MessageHub3:3
+ sessionAfterRegistering = messageHub2->getSessionWithId(sessionId2);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ sessionAfterRegistering2 = messageHub3->getSessionWithId(sessionId2);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId2).has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Find session: MessageHub3:3 -> MessageHub1:1
+ sessionAfterRegistering = messageHub3->getSessionWithId(sessionId3);
+ EXPECT_TRUE(sessionAfterRegistering.has_value());
+ sessionAfterRegistering2 = messageHub->getSessionWithId(sessionId3);
+ EXPECT_TRUE(sessionAfterRegistering2.has_value());
+ EXPECT_FALSE(messageHub2->getSessionWithId(sessionId3).has_value());
+ EXPECT_EQ(*sessionAfterRegistering, *sessionAfterRegistering2);
+
+ // Close sessions from receivers and verify they are closed on all hubs
+ EXPECT_TRUE(messageHub2->closeSession(sessionId));
+ EXPECT_TRUE(messageHub3->closeSession(sessionId2));
+ EXPECT_TRUE(messageHub->closeSession(sessionId3));
+ for (SessionId id : {sessionId, sessionId2, sessionId3}) {
+ EXPECT_FALSE(messageHub->getSessionWithId(id).has_value());
+ EXPECT_FALSE(messageHub2->getSessionWithId(id).has_value());
+ EXPECT_FALSE(messageHub3->getSessionWithId(id).has_value());
+ }
+}
+
+TEST_F(MessageRouterTest, SendMessageToSession) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ constexpr size_t kMessageSize = 5;
+ pw::UniquePtr<std::byte[]> messageData =
+ mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ Message messageFromCallback1;
+ Message messageFromCallback2;
+ Message messageFromCallback3;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ Session sessionFromCallback3;
+ MessageHubCallbackStoreData callback(&messageFromCallback1,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(&messageFromCallback2,
+ &sessionFromCallback2);
+ MessageHubCallbackStoreData callback3(&messageFromCallback3,
+ &sessionFromCallback3);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send message from messageHub:1 to messageHub2:2
+ ASSERT_TRUE(messageHub->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0, sessionId));
+ EXPECT_EQ(messageFromCallback2.sessionId, sessionId);
+ EXPECT_EQ(messageFromCallback2.sender.messageHubId, messageHub->getId());
+ EXPECT_EQ(messageFromCallback2.sender.endpointId, kEndpointInfos[0].id);
+ EXPECT_EQ(messageFromCallback2.recipient.messageHubId, messageHub2->getId());
+ EXPECT_EQ(messageFromCallback2.recipient.endpointId, kEndpointInfos[1].id);
+ EXPECT_EQ(messageFromCallback2.messageType, 1);
+ EXPECT_EQ(messageFromCallback2.messagePermissions, 0);
+ EXPECT_EQ(messageFromCallback2.length, kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ EXPECT_EQ(messageFromCallback2.data[i], static_cast<std::byte>(i + 1));
+ }
+
+ messageData = mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ // Send message from messageHub2:2 to messageHub:1
+ ASSERT_TRUE(messageHub2->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 2,
+ /* messagePermissions= */ 3, sessionId));
+ EXPECT_EQ(messageFromCallback1.sessionId, sessionId);
+ EXPECT_EQ(messageFromCallback1.sender.messageHubId, messageHub2->getId());
+ EXPECT_EQ(messageFromCallback1.sender.endpointId, kEndpointInfos[1].id);
+ EXPECT_EQ(messageFromCallback1.recipient.messageHubId, messageHub->getId());
+ EXPECT_EQ(messageFromCallback1.recipient.endpointId, kEndpointInfos[0].id);
+ EXPECT_EQ(messageFromCallback1.messageType, 2);
+ EXPECT_EQ(messageFromCallback1.messagePermissions, 3);
+ EXPECT_EQ(messageFromCallback1.length, kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ EXPECT_EQ(messageFromCallback1.data[i], static_cast<std::byte>(i + 1));
+ }
+}
+
+TEST_F(MessageRouterTest, SendMessageToSessionUsingPointerAndFreeCallback) {
+ struct FreeCallbackContext {
+ bool *freeCallbackCalled;
+ std::byte *message;
+ size_t length;
+ };
+
+ pw::Vector<
+ MessageRouterCallbackAllocator<FreeCallbackContext>::FreeCallbackRecord,
+ 10>
+ freeCallbackRecords;
+ MessageRouterCallbackAllocator<FreeCallbackContext> allocator(
+ [](std::byte *message, size_t length,
+ const FreeCallbackContext &context) {
+ *context.freeCallbackCalled =
+ message == context.message && length == context.length;
+ },
+ freeCallbackRecords);
+
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ constexpr size_t kMessageSize = 5;
+ std::byte messageData[kMessageSize];
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ Message messageFromCallback1;
+ Message messageFromCallback2;
+ Message messageFromCallback3;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ Session sessionFromCallback3;
+ MessageHubCallbackStoreData callback(&messageFromCallback1,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(&messageFromCallback2,
+ &sessionFromCallback2);
+ MessageHubCallbackStoreData callback3(&messageFromCallback3,
+ &sessionFromCallback3);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send message from messageHub:1 to messageHub2:2
+ bool freeCallbackCalled = false;
+ FreeCallbackContext freeCallbackContext = {
+ .freeCallbackCalled = &freeCallbackCalled,
+ .message = messageData,
+ .length = kMessageSize,
+ };
+ pw::UniquePtr<std::byte[]> data = allocator.MakeUniqueArrayWithCallback(
+ messageData, kMessageSize, std::move(freeCallbackContext));
+ ASSERT_NE(data.get(), nullptr);
+
+ ASSERT_TRUE(messageHub->sendMessage(std::move(data), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0, sessionId));
+ EXPECT_EQ(messageFromCallback2.sessionId, sessionId);
+ EXPECT_EQ(messageFromCallback2.sender.messageHubId, messageHub->getId());
+ EXPECT_EQ(messageFromCallback2.sender.endpointId, kEndpointInfos[0].id);
+ EXPECT_EQ(messageFromCallback2.recipient.messageHubId, messageHub2->getId());
+ EXPECT_EQ(messageFromCallback2.recipient.endpointId, kEndpointInfos[1].id);
+ EXPECT_EQ(messageFromCallback2.messageType, 1);
+ EXPECT_EQ(messageFromCallback2.messagePermissions, 0);
+ EXPECT_EQ(messageFromCallback2.length, kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ EXPECT_EQ(messageFromCallback2.data[i], static_cast<std::byte>(i + 1));
+ }
+
+ // Check if free callback was called
+ EXPECT_FALSE(freeCallbackCalled);
+ EXPECT_EQ(messageFromCallback2.data.get(), messageData);
+ messageFromCallback2.data.Reset();
+ EXPECT_TRUE(freeCallbackCalled);
+
+ // Send message from messageHub2:2 to messageHub:1
+ freeCallbackCalled = false;
+ FreeCallbackContext freeCallbackContext2 = {
+ .freeCallbackCalled = &freeCallbackCalled,
+ .message = messageData,
+ .length = kMessageSize,
+ };
+ data = allocator.MakeUniqueArrayWithCallback(messageData, kMessageSize,
+ std::move(freeCallbackContext2));
+ ASSERT_NE(data.get(), nullptr);
+
+ ASSERT_TRUE(messageHub2->sendMessage(std::move(data), kMessageSize,
+ /* messageType= */ 2,
+ /* messagePermissions= */ 3, sessionId));
+ EXPECT_EQ(messageFromCallback1.sessionId, sessionId);
+ EXPECT_EQ(messageFromCallback1.sender.messageHubId, messageHub2->getId());
+ EXPECT_EQ(messageFromCallback1.sender.endpointId, kEndpointInfos[1].id);
+ EXPECT_EQ(messageFromCallback1.recipient.messageHubId, messageHub->getId());
+ EXPECT_EQ(messageFromCallback1.recipient.endpointId, kEndpointInfos[0].id);
+ EXPECT_EQ(messageFromCallback1.messageType, 2);
+ EXPECT_EQ(messageFromCallback1.messagePermissions, 3);
+ EXPECT_EQ(messageFromCallback1.length, kMessageSize);
+ for (size_t i = 0; i < kMessageSize; ++i) {
+ EXPECT_EQ(messageFromCallback1.data[i], static_cast<std::byte>(i + 1));
+ }
+
+ // Check if free callback was called
+ EXPECT_FALSE(freeCallbackCalled);
+ EXPECT_EQ(messageFromCallback1.data.get(), messageData);
+ messageFromCallback1.data.Reset();
+ EXPECT_TRUE(freeCallbackCalled);
+}
+
+TEST_F(MessageRouterTest, SendMessageToSessionInvalidHubAndSession) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ constexpr size_t kMessageSize = 5;
+ pw::UniquePtr<std::byte[]> messageData =
+ mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ Message messageFromCallback1;
+ Message messageFromCallback2;
+ Message messageFromCallback3;
+ Session sessionFromCallback1;
+ Session sessionFromCallback2;
+ Session sessionFromCallback3;
+ MessageHubCallbackStoreData callback(&messageFromCallback1,
+ &sessionFromCallback1);
+ MessageHubCallbackStoreData callback2(&messageFromCallback2,
+ &sessionFromCallback2);
+ MessageHubCallbackStoreData callback3(&messageFromCallback3,
+ &sessionFromCallback3);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send message from messageHub:1 to messageHub2:2
+ EXPECT_FALSE(messageHub->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0,
+ sessionId2));
+ EXPECT_FALSE(messageHub2->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 2,
+ /* messagePermissions= */ 3,
+ sessionId3));
+ EXPECT_FALSE(messageHub3->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 2,
+ /* messagePermissions= */ 3,
+ sessionId));
+}
+
+TEST_F(MessageRouterTest, SendMessageToSessionCallbackFailureClosesSession) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ constexpr size_t kMessageSize = 5;
+ pw::UniquePtr<std::byte[]> messageData =
+ mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ bool wasMessageReceivedCalled1 = false;
+ bool wasMessageReceivedCalled2 = false;
+ bool wasMessageReceivedCalled3 = false;
+ MessageHubCallbackAlwaysFails callback1(
+ &wasMessageReceivedCalled1,
+ /* wasSessionClosedCalled= */ nullptr);
+ MessageHubCallbackAlwaysFails callback2(
+ &wasMessageReceivedCalled2,
+ /* wasSessionClosedCalled= */ nullptr);
+ MessageHubCallbackAlwaysFails callback3(
+ &wasMessageReceivedCalled3,
+ /* wasSessionClosedCalled= */ nullptr);
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback1);
+ EXPECT_TRUE(messageHub.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send message from messageHub2:2 to messageHub3:3
+ EXPECT_FALSE(wasMessageReceivedCalled1);
+ EXPECT_FALSE(wasMessageReceivedCalled2);
+ EXPECT_FALSE(wasMessageReceivedCalled3);
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId2).has_value());
+ EXPECT_TRUE(messageHub2->getSessionWithId(sessionId2).has_value());
+ EXPECT_TRUE(messageHub3->getSessionWithId(sessionId2).has_value());
+
+ EXPECT_FALSE(messageHub2->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0,
+ sessionId2));
+ EXPECT_FALSE(wasMessageReceivedCalled1);
+ EXPECT_FALSE(wasMessageReceivedCalled2);
+ EXPECT_TRUE(wasMessageReceivedCalled3);
+ EXPECT_FALSE(messageHub->getSessionWithId(sessionId2).has_value());
+ EXPECT_FALSE(messageHub2->getSessionWithId(sessionId2).has_value());
+ EXPECT_FALSE(messageHub3->getSessionWithId(sessionId2).has_value());
+
+ // Try to send a message on the same session - should fail
+ wasMessageReceivedCalled1 = false;
+ wasMessageReceivedCalled2 = false;
+ wasMessageReceivedCalled3 = false;
+ messageData = mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+ EXPECT_FALSE(messageHub2->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0,
+ sessionId2));
+ messageData = mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+ EXPECT_FALSE(messageHub3->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0,
+ sessionId2));
+ EXPECT_FALSE(wasMessageReceivedCalled1);
+ EXPECT_FALSE(wasMessageReceivedCalled2);
+ EXPECT_FALSE(wasMessageReceivedCalled3);
+}
+
+TEST_F(MessageRouterTest, MessageHubCallbackCanCallOtherMessageHubAPIs) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ constexpr size_t kMessageSize = 5;
+ pw::UniquePtr<std::byte[]> messageData =
+ mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+
+ MessageHubCallbackCallsMessageHubApisDuringCallback callback;
+ MessageHubCallbackCallsMessageHubApisDuringCallback callback2;
+ MessageHubCallbackCallsMessageHubApisDuringCallback callback3;
+
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+ callback.setMessageHub(&messageHub.value());
+ std::optional<MessageRouter::MessageHub> messageHub2 =
+ router.registerMessageHub("hub2", /* id= */ 2, callback2);
+ EXPECT_TRUE(messageHub2.has_value());
+ callback2.setMessageHub(&messageHub2.value());
+ std::optional<MessageRouter::MessageHub> messageHub3 =
+ router.registerMessageHub("hub3", /* id= */ 3, callback3);
+ EXPECT_TRUE(messageHub3.has_value());
+ callback3.setMessageHub(&messageHub3.value());
+
+ // Open session from messageHub:1 to messageHub2:2
+ SessionId sessionId = messageHub->openSession(
+ kEndpointInfos[0].id, messageHub2->getId(), kEndpointInfos[1].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub2:2 to messageHub3:3
+ SessionId sessionId2 = messageHub2->openSession(
+ kEndpointInfos[1].id, messageHub3->getId(), kEndpointInfos[2].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Open session from messageHub3:3 to messageHub1:1
+ SessionId sessionId3 = messageHub3->openSession(
+ kEndpointInfos[2].id, messageHub->getId(), kEndpointInfos[0].id);
+ EXPECT_NE(sessionId, SESSION_ID_INVALID);
+
+ // Send message from messageHub:1 to messageHub2:2
+ EXPECT_TRUE(messageHub->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 1,
+ /* messagePermissions= */ 0, sessionId));
+
+ // Send message from messageHub2:2 to messageHub:1
+ messageData = mAllocator.MakeUniqueArray<std::byte>(kMessageSize);
+ for (size_t i = 0; i < 5; ++i) {
+ messageData[i] = static_cast<std::byte>(i + 1);
+ }
+ EXPECT_TRUE(messageHub2->sendMessage(std::move(messageData), kMessageSize,
+ /* messageType= */ 2,
+ /* messagePermissions= */ 3, sessionId));
+
+ // Close all sessions
+ EXPECT_TRUE(messageHub->closeSession(sessionId));
+ EXPECT_TRUE(messageHub2->closeSession(sessionId2));
+ EXPECT_TRUE(messageHub3->closeSession(sessionId3));
+
+ // If we finish the test, both callbacks should have been called
+ // If the router holds the lock during the callback, this test will timeout
+}
+
+TEST_F(MessageRouterTest, ForEachEndpointOfHub) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+
+ DynamicVector<EndpointInfo> endpoints;
+ EXPECT_TRUE(router.forEachEndpointOfHub(
+ /* messageHubId= */ 1, [&endpoints](const EndpointInfo &info) {
+ endpoints.push_back(info);
+ return false;
+ }));
+ EXPECT_EQ(endpoints.size(), kNumEndpoints);
+ for (size_t i = 0; i < endpoints.size(); ++i) {
+ EXPECT_EQ(endpoints[i].id, kEndpointInfos[i].id);
+ EXPECT_STREQ(endpoints[i].name, kEndpointInfos[i].name);
+ EXPECT_EQ(endpoints[i].version, kEndpointInfos[i].version);
+ EXPECT_EQ(endpoints[i].type, kEndpointInfos[i].type);
+ EXPECT_EQ(endpoints[i].requiredPermissions,
+ kEndpointInfos[i].requiredPermissions);
+ }
+}
+
+TEST_F(MessageRouterTest, ForEachEndpoint) {
+ const char *kHubName = "hub1";
+ constexpr MessageHubId kHubId = 1;
+
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub(kHubName, kHubId, callback);
+ EXPECT_TRUE(messageHub.has_value());
+
+ DynamicVector<std::pair<MessageHubInfo, EndpointInfo>> endpoints;
+ router.forEachEndpoint(
+ [&endpoints](const MessageHubInfo &hubInfo, const EndpointInfo &info) {
+ endpoints.push_back(std::make_pair(hubInfo, info));
+ });
+ EXPECT_EQ(endpoints.size(), kNumEndpoints);
+ for (size_t i = 0; i < endpoints.size(); ++i) {
+ EXPECT_EQ(endpoints[i].first.id, kHubId);
+ EXPECT_STREQ(endpoints[i].first.name, kHubName);
+
+ EXPECT_EQ(endpoints[i].second.id, kEndpointInfos[i].id);
+ EXPECT_STREQ(endpoints[i].second.name, kEndpointInfos[i].name);
+ EXPECT_EQ(endpoints[i].second.version, kEndpointInfos[i].version);
+ EXPECT_EQ(endpoints[i].second.type, kEndpointInfos[i].type);
+ EXPECT_EQ(endpoints[i].second.requiredPermissions,
+ kEndpointInfos[i].requiredPermissions);
+ }
+}
+
+TEST_F(MessageRouterTest, ForEachEndpointOfHubInvalidHub) {
+ MessageRouterWithStorage<kMaxMessageHubs, kMaxSessions> router;
+ MessageHubCallbackStoreData callback(/* message= */ nullptr,
+ /* session= */ nullptr);
+ std::optional<MessageRouter::MessageHub> messageHub =
+ router.registerMessageHub("hub1", /* id= */ 1, callback);
+ EXPECT_TRUE(messageHub.has_value());
+
+ DynamicVector<EndpointInfo> endpoints;
+ EXPECT_FALSE(router.forEachEndpointOfHub(
+ /* messageHubId= */ 2, [&endpoints](const EndpointInfo &info) {
+ endpoints.push_back(info);
+ return false;
+ }));
+ EXPECT_EQ(endpoints.size(), 0);
+}
+
+} // namespace
+} // namespace chre::message
diff --git a/util/tests/priority_queue_test.cc b/util/tests/priority_queue_test.cc
index f6deb66..1d9a173 100644
--- a/util/tests/priority_queue_test.cc
+++ b/util/tests/priority_queue_test.cc
@@ -22,12 +22,14 @@
namespace {
class FakeElement {
public:
- FakeElement(){};
+ FakeElement() {}
FakeElement(int index, int value) {
mValue = value;
mIndex = index;
- };
- ~FakeElement(){};
+ }
+
+ ~FakeElement() {}
+
void setValue(int value) {
mValue = value;
}
@@ -45,7 +47,7 @@
bool compareFunction(const FakeElement &left, const FakeElement &right) {
return left.getValue() > right.getValue();
-};
+}
class CompareClass {
public:
diff --git a/util/tests/synchronized_expandable_memory_pool_test.cc b/util/tests/synchronized_expandable_memory_pool_test.cc
index f5957a9..ee62dfb 100644
--- a/util/tests/synchronized_expandable_memory_pool_test.cc
+++ b/util/tests/synchronized_expandable_memory_pool_test.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "chre/util/synchronized_expandable_memory_pool.h"
+#include "chre/util/system/synchronized_expandable_memory_pool.h"
#include "gtest/gtest.h"
diff --git a/util/tests/synchronized_memory_pool_test.cc b/util/tests/synchronized_memory_pool_test.cc
index cecff88..35127ec 100644
--- a/util/tests/synchronized_memory_pool_test.cc
+++ b/util/tests/synchronized_memory_pool_test.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "chre/util/synchronized_memory_pool.h"
+#include "chre/util/system/synchronized_memory_pool.h"
#include "gtest/gtest.h"
diff --git a/util/tests/transaction_manager_test.cc b/util/tests/transaction_manager_test.cc
index 0c70b2f..7df617b 100644
--- a/util/tests/transaction_manager_test.cc
+++ b/util/tests/transaction_manager_test.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "chre/util/transaction_manager.h"
+#include "chre/util/system/transaction_manager.h"
#include <algorithm>
#include <map>
diff --git a/util/util.mk b/util/util.mk
index b03bd26..4e5cd1e 100644
--- a/util/util.mk
+++ b/util/util.mk
@@ -2,11 +2,35 @@
# Util Makefile
#
+# Location of various Pigweed modules #########################################
+
+PIGWEED_DIR = $(ANDROID_BUILD_TOP)/external/pigweed
+PIGWEED_CHRE_DIR = $(ANDROID_BUILD_TOP)/system/chre/external/pigweed
+
# Common Compiler Flags ########################################################
# Include paths.
COMMON_CFLAGS += -I$(CHRE_PREFIX)/util/include
+# Pigweed ######################################################################
+
+COMMON_CFLAGS += -I$(PIGWEED_CHRE_DIR)/pw_log_nanoapp/public_overrides
+COMMON_CFLAGS += -I$(PIGWEED_CHRE_DIR)/pw_assert_nanoapp/public_overrides
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_allocator/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_assert/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_containers/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_function/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_log/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_polyfill/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_preprocessor/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_result/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_span/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/pw_status/public
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/third_party/fuchsia/repo/sdk/lib/fit/include
+COMMON_CFLAGS += -I$(PIGWEED_DIR)/third_party/fuchsia/repo/sdk/lib/stdcompat/include
+
+COMMON_SRCS += $(PIGWEED_DIR)/pw_allocator/unique_ptr.cc
+
# Common Source Files ##########################################################
COMMON_SRCS += $(CHRE_PREFIX)/util/buffer_base.cc
@@ -23,6 +47,7 @@
COMMON_SRCS += $(CHRE_PREFIX)/util/system/ble_util.cc
COMMON_SRCS += $(CHRE_PREFIX)/util/system/event_callbacks.cc
COMMON_SRCS += $(CHRE_PREFIX)/util/system/debug_dump.cc
+COMMON_SRCS += $(CHRE_PREFIX)/util/system/message_router.cc
# GoogleTest Source Files ######################################################
diff --git a/variant/CMakeLists.txt b/variant/CMakeLists.txt
new file mode 100644
index 0000000..1a09fb8
--- /dev/null
+++ b/variant/CMakeLists.txt
@@ -0,0 +1,13 @@
+include($ENV{PW_ROOT}/pw_build/pigweed.cmake)
+
+pw_add_module_config(chre_variant_CONFIG)
+pw_add_library(chre.variant.config INTERFACE
+ HEADERS
+ include/chre/variant/config.h
+ PUBLIC_INCLUDES
+ include
+ PUBLIC_DEPS
+ "${chre_variant_CONFIG}"
+ PUBLIC_COMPILE_OPTIONS
+ --include=${CMAKE_CURRENT_SOURCE_DIR}/include/chre/variant/config.h
+)
diff --git a/variant/include/chre/variant/config.h b/variant/include/chre/variant/config.h
new file mode 100644
index 0000000..9a94d52
--- /dev/null
+++ b/variant/include/chre/variant/config.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+// TODO: b/376532038 - Refactor the platform layer to provide static nanoapps
+// instead of having it conditionally come out of core/static_nanoapps.cc to
+// ensure the build graph can properly represent chre.core.
+#if defined(CHRE_INCLUDE_DEFAULT_STATIC_NANOAPPS)
+// This cannot be supported due to how the build rules are set up. Ideally this
+// would be part of a shared platform layer, but it's in fact part of core.
+#error "CMake does not permit the built in default static nanoapps"
+#endif // defined(CHRE_INCLUDE_DEFAULT_STATIC_NANOAPPS)
+
+// This should provide all CHRE_* configuration defines.
+#include "chre/target_variant/config.h"
diff --git a/variant/tinysys/variant.mk b/variant/tinysys/variant.mk
index 5849305..ccb2db5 100644
--- a/variant/tinysys/variant.mk
+++ b/variant/tinysys/variant.mk
@@ -53,20 +53,21 @@
TINYSYS_CFLAGS += -I$(RISCV_TINYSYS_PREFIX)/scp/project/RV55_A/$(TINYSYS_PLATFORM)/platform/inc
TINYSYS_CFLAGS += -I$(RISCV_TINYSYS_PREFIX)/scp/project/RV55_A/common/platform/inc
-# Clang include paths
-TINYSYS_CFLAGS += -I$(RISCV_TOOLCHAIN_PATH)/lib/clang/9.0.1/include
-TINYSYS_CFLAGS += -I$(RISCV_TOOLCHAIN_PATH)/dkwlib/MRV55E03v/include
-
# Common Compiler Flags ########################################################
# Supply a symbol to indicate that the build variant supplies the static
# nanoapp list.
COMMON_CFLAGS += -DCHRE_VARIANT_SUPPLIES_STATIC_NANOAPP_LIST
+# Enable nanoapp authentication by default
+TINYSYS_CFLAGS += -DCHRE_NAPP_AUTHENTICATION_ENABLED
+
# CHRE event count #############################################################
TINYSYS_CFLAGS += -DCHRE_EVENT_PER_BLOCK=32
TINYSYS_CFLAGS += -DCHRE_MAX_EVENT_BLOCKS=4
+TINYSYS_CFLAGS += -DCHRE_UNSCHEDULED_EVENT_PER_BLOCK=32
+TINYSYS_CFLAGS += -DCHRE_MAX_UNSCHEDULED_EVENT_BLOCKS=4
# Optional Features ############################################################
@@ -74,7 +75,7 @@
CHRE_GNSS_SUPPORT_ENABLED = true
CHRE_SENSORS_SUPPORT_ENABLED = true
CHRE_WIFI_SUPPORT_ENABLED = true
-CHRE_WWAN_SUPPORT_ENABLED = false
+CHRE_WWAN_SUPPORT_ENABLED = true
CHRE_BLE_SUPPORT_ENABLED = true
# Common Source Files ##########################################################
