blob: 4950627a2da0ab8db239f99fb56baf57b62202f6 [file] [log] [blame]
* 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
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
package android.hardware.contexthub@1.0;
enum Result : uint32_t {
OK, // Success
UNKNOWN_FAILURE, // Failure, unknown reason
BAD_PARAMS, // Parameters not sane
NOT_INIT, // Not initialized
TRANSACTION_FAILED, // Transaction failed
TRANSACTION_PENDING, // Pending transaction, cannot accept a new request
enum NanoAppFlags : uint32_t {
SIGNED = 1 << 0,
ENCRYPTED = 1 << 1,
struct NanoAppBinary {
uint64_t appId; // Nanoapp identifier
uint32_t appVersion; // Version of the app (semantics defined by app)
bitfield<NanoAppFlags> flags;
// The version of the CHRE API that this nanoApp was compiled against. See
// the CHRE API header file chre/version.h for more information. The hub
// implementation must use this to confirm compatibility before loading
// this nanoApp.
uint8_t targetChreApiMajorVersion;
uint8_t targetChreApiMinorVersion;
// Implementation-specific binary nanoapp data. This does not include the
// common nanoapp header that contains the app ID, etc., as this data is
// explicitly passed through the other fields in this struct.
vec<uint8_t> customBinary;
enum SensorType : uint32_t {
GPS = 0x100,
// Reserving this space for variants on GPS
WIFI = 0x200,
// Reserving this space for variants on WIFI
AUDIO = 0x300,
// Reserving this space for variants on Audio
CAMERA = 0x400,
// Reserving this space for variants on Camera
BLE = 0x500,
// Reserving this space for variants on Bluetooth Low Energy
WWAN = 0x600,
// Reserving this space for variants on WWAN
// Sensor types beyond PRIVATE_SENSOR_BASE are custom types
struct PhysicalSensor{
SensorType sensorType; // From the definitions above eg: 100
string type; // Type as a string. eg: "GPS"
string name; // Identifier eg: "Bosch BMI160"
string vendor; // Vendor : eg "STM"
uint32_t version; // Version : eg 0x1001
uint32_t fifoReservedCount; // Batching possible in hardware. Please
// note that here hardware does not include
// the context hub itself. Thus, this
// definition may be different from say the
// number advertised in the sensors HAL
// which allows for batching in a hub.
uint32_t fifoMaxCount; // Maximum number of batchable events.
uint64_t minDelayMs; // In milliseconds, corresponding to highest
// sampling freq.
uint64_t maxDelayMs; // In milliseconds, corresponds to minimum
// sampling frequency
float peakPowerMw; // At max frequency & no batching, power
// in milliwatts
struct ContextHub {
string name; // Descriptive name eg: "Awesome Hub #1"
string vendor; // Hub hardware vendor eg: "Qualcomm"
string toolchain; // Toolchain to make binaries eg: "gcc ARM"
uint32_t platformVersion; // Version of the hardware : eg 0x20
uint32_t toolchainVersion; // Version of the toolchain : eg: 0x484
uint32_t hubId; // A device unique ID for this hub
float peakMips; // Peak MIPS platform can deliver
float stoppedPowerDrawMw; // If stopped, retention power, milliwatts
float sleepPowerDrawMw; // If sleeping, retention power, milliwatts
float peakPowerDrawMw; // For a busy CPU, power in milliwatts
vec<PhysicalSensor> connectedSensors; // Array of connected sensors
uint32_t maxSupportedMsgLen;// This is the maximum size of the message that can
// be sent to the hub in one chunk (in bytes)
// Machine-readable CHRE platform ID, returned to nanoapps in the CHRE API
// function call chreGetPlatformId(). This field pairs with
// chreApiMajorVersion, chreApiMinorVersion, and chrePatchVersion to fully
// specify the CHRE implementation version. See also the CHRE API header
// file chre/version.h.
uint64_t chrePlatformId;
// The version of the CHRE implementation returned to nanoApps in the CHRE
// API function call chreGetVersion(). The major and minor version specify
// the implemented version of the CHRE API, while the patch version
// describes the implementation version within the scope of the platform
// ID. See also the CHRE API header file chre/version.h.
uint8_t chreApiMajorVersion;
uint8_t chreApiMinorVersion;
uint16_t chrePatchVersion;
enum HostEndPoint : uint16_t {
BROADCAST = 0xFFFF, // The message endpoint is a broadcast end point.
// This value must never be used for a message from
// the host to the hub.
// If BROADCAST is specified as a destination for a
// message from the context hub to the ContextHub
// service, the message must be broadcast to all
// registered clients by the Context Hub service.
UNSPECIFIED = 0xFFFE, // The message endpoint is unspecified. This value
// must not be used for messages from the hub to host.
// This value may be used for messages from the host
// to the hub.
struct ContextHubMsg {
uint64_t appName; // Intended recipient (appId)
uint16_t hostEndPoint; // identifier for the endpoint. (also see enum HostEndPoint)
uint32_t msgType; // Identifier for message
vec<uint8_t> msg; // Message body
enum HubMemoryType : uint32_t {
MAIN = 0, // Main memory
SECONDARY = 1, // Secondary memory
TCM = 2, // Tightly coupled memory
enum HubMemoryFlag : uint32_t {
READ = 1 << 0, // Readable
WRITE = 1 << 1, // Writable
EXEC = 1 << 2, // Executable
struct MemRange {
uint32_t totalBytes; // Total capacity in bytes
uint32_t freeBytes; // Free capacity in bytes
HubMemoryType type; // Type of memory, see HubMemoryType
bitfield<HubMemoryFlag> flags;
enum AsyncEventType : uint32_t {
RESTARTED = 1, // Hub restarted unexpectedly
enum TransactionResult : int32_t {
SUCCESS, // Successful completion of transaction
FAILURE, // Failed transaction
struct HubAppInfo {
uint64_t appId; // Identifier of the app
uint32_t version; // Version of the app
vec<MemRange> memUsage; // Memory used by this app
bool enabled; // true if the app is currently enabled and running,
// or false if in the loaded but disabled state