| /* |
| * 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_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. |
| CHRE_ERROR_OBSOLETE_REQUEST = 10, |
| |
| //!< 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_ */ |