app_event_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef _APP_EVENT_MANAGER_H_
#define _APP_EVENT_MANAGER_H_
 
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>
 
#include <app_event_manager_priv.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef bool (*cb_fn)(const struct app_event_header *aeh);
enum app_event_type_flags {
        APP_EVENT_TYPE_FLAGS_SYSTEM_START,
        APP_EVENT_TYPE_FLAGS_HAS_DYNDATA = APP_EVENT_TYPE_FLAGS_SYSTEM_START,
        APP_EVENT_TYPE_FLAGS_USER_SETTABLE_START,
        APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE =
                APP_EVENT_TYPE_FLAGS_USER_SETTABLE_START,
        APP_EVENT_TYPE_FLAGS_COUNT,
        APP_EVENT_TYPE_FLAGS_USER_DEFINED_START = APP_EVENT_TYPE_FLAGS_COUNT,
};
 
static inline bool app_event_get_type_flag(const struct event_type *et,
                                           enum app_event_type_flags flag)
{
        return (et->flags & BIT(flag)) != 0;
}
 
#define APP_EVENT_ID(ename) _EVENT_ID(ename)
 
#define APP_EVENT_LISTENER(lname, cb_fn) _APP_EVENT_LISTENER(lname, cb_fn)
 
 
#define APP_EVENT_SUBSCRIBE_FIRST(lname, ename)                                         \
        _APP_EVENT_SUBSCRIBE(lname, ename, _APP_EM_MARKER_FIRST_ELEMENT);                       \
        const struct {} _CONCAT(_CONCAT(__event_subscriber_, ename), first_sub_redefined) = {}
 
 
#define APP_EVENT_SUBSCRIBE_EARLY(lname, ename) \
        _APP_EVENT_SUBSCRIBE(lname, ename, _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_EARLY))
 
 
#define APP_EVENT_SUBSCRIBE(lname, ename) \
        _APP_EVENT_SUBSCRIBE(lname, ename, _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_NORMAL))
 
 
#define APP_EVENT_SUBSCRIBE_FINAL(lname, ename)                                         \
        _APP_EVENT_SUBSCRIBE(lname, ename, _APP_EM_MARKER_FINAL_ELEMENT);                       \
        const struct {} _CONCAT(_CONCAT(__event_subscriber_, ename), final_sub_redefined) = {}
 
 
#define APP_EVENT_TYPE_DECLARE(ename) _APP_EVENT_TYPE_DECLARE(ename)
 
 
#define APP_EVENT_TYPE_DYNDATA_DECLARE(ename) _APP_EVENT_TYPE_DYNDATA_DECLARE(ename)
 
 
#define APP_EVENT_TYPE_DEFINE(ename, log_fn, ev_info_struct, app_event_type_flags) \
        _APP_EVENT_TYPE_DEFINE(ename, log_fn, ev_info_struct, app_event_type_flags)
 
 
#define APP_EVENT_ASSERT_ID(id) \
        __ASSERT_NO_MSG((id >= _event_type_list_start) && (id < _event_type_list_end))
 
#define APP_EVENT_SUBMIT(event) _event_submit(&event->header)
 
#define APP_EVENT_MANAGER_HOOK_POSTINIT_REGISTER(hook_fn)       \
        _APP_EVENT_MANAGER_HOOK_POSTINIT_REGISTER(hook_fn,      \
        _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_NORMAL))
 
static inline size_t app_event_manager_event_size(const struct app_event_header *aeh)
{
#if IS_ENABLED(CONFIG_APP_EVENT_MANAGER_PROVIDE_EVENT_SIZE)
        size_t size = aeh->type_id->struct_size;
 
        if (app_event_get_type_flag(aeh->type_id, APP_EVENT_TYPE_FLAGS_HAS_DYNDATA)) {
                size += ((const struct event_dyndata *)
                         (((const uint8_t *)aeh) + size - sizeof(struct event_dyndata)))->size;
        }
        return size;
#else
        __ASSERT_NO_MSG(false);
        return 0;
#endif
}
 
 
#define APP_EVENT_HOOK_ON_SUBMIT_REGISTER_FIRST(hook_fn)                      \
        const struct {} __event_hook_on_submit_first_sub_redefined = {};  \
        _APP_EVENT_HOOK_ON_SUBMIT_REGISTER(hook_fn, _APP_EM_MARKER_FIRST_ELEMENT)
 
#define APP_EVENT_HOOK_ON_SUBMIT_REGISTER(hook_fn) \
        _APP_EVENT_HOOK_ON_SUBMIT_REGISTER(hook_fn, _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_NORMAL))
 
#define APP_EVENT_HOOK_ON_SUBMIT_REGISTER_LAST(hook_fn)                      \
        const struct {} __event_hook_on_submit_last_sub_redefined = {};  \
        _APP_EVENT_HOOK_ON_SUBMIT_REGISTER(hook_fn, _APP_EM_MARKER_FINAL_ELEMENT)
 
#define APP_EVENT_HOOK_PREPROCESS_REGISTER_FIRST(hook_fn)                      \
        const struct {} __event_hook_preprocess_first_sub_redefined = {};  \
        _APP_EVENT_HOOK_PREPROCESS_REGISTER(hook_fn, _APP_EM_MARKER_FIRST_ELEMENT)
 
#define APP_EVENT_HOOK_PREPROCESS_REGISTER(hook_fn) \
        _APP_EVENT_HOOK_PREPROCESS_REGISTER(hook_fn, _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_NORMAL))
 
#define APP_EVENT_HOOK_PREPROCESS_REGISTER_LAST(hook_fn)                      \
        const struct {} __event_hook_preprocess_last_sub_redefined = {};  \
        _APP_EVENT_HOOK_PREPROCESS_REGISTER(hook_fn, _APP_EM_MARKER_FINAL_ELEMENT)
 
#define APP_EVENT_HOOK_POSTPROCESS_REGISTER_FIRST(hook_fn)                      \
        const struct {} __event_hook_postprocess_first_sub_redefined = {};  \
        _APP_EVENT_HOOK_POSTPROCESS_REGISTER(hook_fn, _APP_EM_MARKER_FIRST_ELEMENT)
 
#define APP_EVENT_HOOK_POSTPROCESS_REGISTER(hook_fn)    \
        _APP_EVENT_HOOK_POSTPROCESS_REGISTER(hook_fn,   \
        _APP_EM_SUBS_PRIO_ID(_APP_EM_SUBS_PRIO_NORMAL))
 
#define APP_EVENT_HOOK_POSTPROCESS_REGISTER_LAST(hook_fn)                      \
        const struct {} __event_hook_postprocess_last_sub_redefined = {};  \
        _APP_EVENT_HOOK_POSTPROCESS_REGISTER(hook_fn, _APP_EM_MARKER_FINAL_ELEMENT)
 
 
int app_event_manager_init(void);
 
void *app_event_manager_alloc(size_t size);
 
 
void app_event_manager_free(void *addr);
 
 
#define APP_EVENT_MANAGER_LOG(aeh, ...) do {                                                    \
        LOG_MODULE_DECLARE(app_event_manager, CONFIG_APP_EVENT_MANAGER_LOG_LEVEL);              \
        if (IS_ENABLED(CONFIG_APP_EVENT_MANAGER_LOG_EVENT_TYPE)) {                              \
                LOG_INF("e:%s " GET_ARG_N(1, __VA_ARGS__), aeh->type_id->name                   \
                        COND_CODE_0(NUM_VA_ARGS_LESS_1(__VA_ARGS__),                            \
                            (),                                                                 \
                            (, GET_ARGS_LESS_N(1, __VA_ARGS__))                                 \
                        ));                                                                     \
        } else {                                                                                \
                LOG_INF(__VA_ARGS__);                                                           \
        }                                                                                       \
} while (0)
 
 
 #define APP_EVENT_FLAGS_CREATE(...)                            \
        (FOR_EACH_NONEMPTY_TERM(_APP_EVENT_FLAGS_JOIN, (|), __VA_ARGS__) 0)
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _APP_EVENT_MANAGER_H_ */