| # Context Hub Runtime Environment (CHRE) |
| |
| This project contains the AOSP reference implementation of the Context Hub |
| Runtime Environment (CHRE), which is Android’s platform for developing always-on |
| applications, called *nanoapps*. CHRE runs in a vendor-specific processor that |
| is independent of the main applications processor that runs Android. This |
| enables CHRE and its nanoapps to be more power-efficient for use cases that |
| require frequent background processing of contextual data, like sensor inputs. |
| Nanoapps are written to the CHRE API, which is standardized across all |
| platforms, enabling them to be code-compatible across different devices. |
| |
| The CHRE reference implementation (“CHRE framework”) is designed to be portable |
| across hardware and software platforms. While Android does not require a |
| particular implementation (only compliance to the contracts given in the CHRE |
| API) using the reference implementation helps to reduce the work needed to |
| support CHRE, while also ensuring more consistent behavior for scenarios that |
| can be difficult to enforce via testing. |
| |
| ## Navigating the docs |
| |
| Use the navigation bar at the top and/or the links below to move through the |
| documentation. Raw files can also be found in the `/doc` folder. |
| |
| * Documentation related to the CHRE framework: |
| * [Framework Overview](/doc/framework_overview.md) |
| * [Porting Guide](/doc/porting_guide.md) |
| * [Build System](/doc/framework_build.md) |
| * [Debugging](/doc/framework_debugging.md) |
| * [Testing](/doc/framework_testing.md) |
| * [Vendor Extensions](/doc/vendor_extensions.md) |
| * Documentation related to nanoapps: |
| * [Nanoapp Overview](/doc/nanoapp_overview.md) |
| * [Developer Guide](/doc/nanoapp_developer_guide.md) |
| * [Interacting with Nanoapps](/doc/nanoapp_clients.md) |
| * General documentation: |
| * [Compatibility Design](/doc/compatibility.md) |
| * [Contributing](/doc/contributing.md) |
| |
| The CHRE API and PAL API are also extensively documented using Doxygen syntax. |
| Run `doxygen` in the same folder as `Doxyfile` to generate a browseable HTML |
| version of the documentation. |
| |
| ## Navigating the code |
| |
| This repository (system/chre) contains an assortment of code, structured as |
| follows: |
| |
| - ``apps/``: Public nanoapp source code, including sample nanoapps intended to |
| showcase how to use the CHRE APIs, and test nanoapps used to validate API |
| functionality |
| - ``build/``: Files related to CHRE’s Makefile-based build system, which |
| supports building the CHRE framework and nanoapps using a configurable |
| toolchain |
| - ``chpp/``: Context Hub Peripheral Protocol (CHPP) source code - see the nested |
| README and associated documentation for details |
| - ``chre_api/``: Contains the official definition of the CHRE API (current and |
| past versions), which all CHRE implementations must adhere to |
| - ``core/``: Common CHRE framework code, which is applicable to every platform |
| (contrast to ``platform/``) |
| - ``doc/``: Contains documentation for the CHRE framework and associated topics |
| - ``external/``: Code developed primarily outside of AOSP which (can be) |
| leveraged by CHRE, and is potentially customized for CHRE (e.g. flatbuffers) |
| - ``host/``: Reference code which supports the CHRE implementation, but runs on |
| the applications processor (“host”), for example the Context Hub HAL |
| - ``java/``: Java test code used in conjunction with test nanoapps |
| - ``pal/``: The binary-stable Platform Abstraction Layer (PAL) C API definitions |
| and tests (these PALs may optionally be used by the platform implementation) |
| - ``platform/``: Code related to the implementation of CHRE on a particular |
| platform/device (compare to ``core/``), divided into sub-folders as follows: |
| - ``platform/include``: The interface between common code in ``core/`` and |
| platform-specific code implemented elsewhere in ``platform/`` |
| - ``platform/shared``: Code that may apply to multiple platforms, but is not |
| necessarily applicable to _all_ platforms (as in ``core/``). For example, |
| multiple platforms may choose to use the binary-stable PAL interface - this |
| folder contains source files translating from the C++ platform abstractions |
| to the C PAL APIs. |
| - ``platform/<platform_name>``: Code specific to the platform indicated by |
| ``platform_name`` |
| - ``util/``: Utility code that is not platform-specific, but not part of the |
| core framework implementation. Includes code that is usable by nanoapps. |
| - ``variant/``: Code/configuration that is specific to a particular device (more |
| detail on variants can be found below). For example, multiple generations of a |
| given chip may use the same platform code, but the code may be configured on a |
| per-device basis in the build via ``variant.mk``. |
| |
| Code related to CHRE also exists in other parts of the Android tree, including: |
| |
| - ``hardware/interfaces/contexthub/``: The Context Hub HAL definition |
| - ``frameworks/base/core/java/android/hardware/location/ContextHub*.java``: The |
| APIs used by privileged apps to interact with CHRE and nanoapps |
| - ``frameworks/base/services/core/java/com/android/server/location/ContextHub*.java``: |
| The Context Hub service implementation in system server |
| |
| # Have Questions? |
| |
| If you’re unable to find the answers you’re looking for in CHRE documentation |
| or are looking for specific guidance for your platform, device, or nanoapp, |
| please reach out to the CHRE team via your TAM or through the [Google Issue |
| Tracker](https://developers.google.com/issue-tracker). |
