ESPHome 2025.9.0-dev
Loading...
Searching...
No Matches
application.h
Go to the documentation of this file.
1#pragma once
2
3#include <algorithm>
4#include <limits>
5#include <string>
6#include <vector>
9#include "esphome/core/hal.h"
13
14#ifdef USE_DEVICES
15#include "esphome/core/device.h"
16#endif
17#ifdef USE_AREAS
18#include "esphome/core/area.h"
19#endif
20
21#ifdef USE_SOCKET_SELECT_SUPPORT
22#include <sys/select.h>
23#endif
24
25#ifdef USE_BINARY_SENSOR
27#endif
28#ifdef USE_SENSOR
30#endif
31#ifdef USE_SWITCH
33#endif
34#ifdef USE_BUTTON
36#endif
37#ifdef USE_TEXT_SENSOR
39#endif
40#ifdef USE_FAN
42#endif
43#ifdef USE_CLIMATE
45#endif
46#ifdef USE_LIGHT
48#endif
49#ifdef USE_COVER
51#endif
52#ifdef USE_NUMBER
54#endif
55#ifdef USE_DATETIME_DATE
57#endif
58#ifdef USE_DATETIME_TIME
60#endif
61#ifdef USE_DATETIME_DATETIME
63#endif
64#ifdef USE_TEXT
66#endif
67#ifdef USE_SELECT
69#endif
70#ifdef USE_LOCK
72#endif
73#ifdef USE_VALVE
75#endif
76#ifdef USE_MEDIA_PLAYER
78#endif
79#ifdef USE_ALARM_CONTROL_PANEL
81#endif
82#ifdef USE_EVENT
84#endif
85#ifdef USE_UPDATE
87#endif
88
89namespace esphome {
90
91// Teardown timeout constant (in milliseconds)
92// For reboots, it's more important to shut down quickly than disconnect cleanly
93// since we're not entering deep sleep. The only consequence of not shutting down
94// cleanly is a warning in the log.
95static const uint32_t TEARDOWN_TIMEOUT_REBOOT_MS = 1000; // 1 second for quick reboot
96
98 public:
99 void pre_setup(const std::string &name, const std::string &friendly_name, const char *comment,
100 const char *compilation_time, bool name_add_mac_suffix) {
101 arch_init();
102 this->name_add_mac_suffix_ = name_add_mac_suffix;
103 if (name_add_mac_suffix) {
104 const std::string mac_suffix = get_mac_address().substr(6);
105 this->name_ = name + "-" + mac_suffix;
106 this->friendly_name_ = friendly_name.empty() ? "" : friendly_name + " " + mac_suffix;
107 } else {
108 this->name_ = name;
109 this->friendly_name_ = friendly_name;
110 }
111 this->comment_ = comment;
112 this->compilation_time_ = compilation_time;
113 }
114
115#ifdef USE_DEVICES
116 void register_device(Device *device) { this->devices_.push_back(device); }
117#endif
118#ifdef USE_AREAS
119 void register_area(Area *area) { this->areas_.push_back(area); }
120#endif
121
122 void set_current_component(Component *component) { this->current_component_ = component; }
124
125#ifdef USE_BINARY_SENSOR
127 this->binary_sensors_.push_back(binary_sensor);
128 }
129#endif
130
131#ifdef USE_SENSOR
132 void register_sensor(sensor::Sensor *sensor) { this->sensors_.push_back(sensor); }
133#endif
134
135#ifdef USE_SWITCH
136 void register_switch(switch_::Switch *a_switch) { this->switches_.push_back(a_switch); }
137#endif
138
139#ifdef USE_BUTTON
140 void register_button(button::Button *button) { this->buttons_.push_back(button); }
141#endif
142
143#ifdef USE_TEXT_SENSOR
144 void register_text_sensor(text_sensor::TextSensor *sensor) { this->text_sensors_.push_back(sensor); }
145#endif
146
147#ifdef USE_FAN
148 void register_fan(fan::Fan *state) { this->fans_.push_back(state); }
149#endif
150
151#ifdef USE_COVER
152 void register_cover(cover::Cover *cover) { this->covers_.push_back(cover); }
153#endif
154
155#ifdef USE_CLIMATE
156 void register_climate(climate::Climate *climate) { this->climates_.push_back(climate); }
157#endif
158
159#ifdef USE_LIGHT
160 void register_light(light::LightState *light) { this->lights_.push_back(light); }
161#endif
162
163#ifdef USE_NUMBER
164 void register_number(number::Number *number) { this->numbers_.push_back(number); }
165#endif
166
167#ifdef USE_DATETIME_DATE
168 void register_date(datetime::DateEntity *date) { this->dates_.push_back(date); }
169#endif
170
171#ifdef USE_DATETIME_TIME
172 void register_time(datetime::TimeEntity *time) { this->times_.push_back(time); }
173#endif
174
175#ifdef USE_DATETIME_DATETIME
176 void register_datetime(datetime::DateTimeEntity *datetime) { this->datetimes_.push_back(datetime); }
177#endif
178
179#ifdef USE_TEXT
180 void register_text(text::Text *text) { this->texts_.push_back(text); }
181#endif
182
183#ifdef USE_SELECT
184 void register_select(select::Select *select) { this->selects_.push_back(select); }
185#endif
186
187#ifdef USE_LOCK
188 void register_lock(lock::Lock *a_lock) { this->locks_.push_back(a_lock); }
189#endif
190
191#ifdef USE_VALVE
192 void register_valve(valve::Valve *valve) { this->valves_.push_back(valve); }
193#endif
194
195#ifdef USE_MEDIA_PLAYER
196 void register_media_player(media_player::MediaPlayer *media_player) { this->media_players_.push_back(media_player); }
197#endif
198
199#ifdef USE_ALARM_CONTROL_PANEL
201 this->alarm_control_panels_.push_back(a_alarm_control_panel);
202 }
203#endif
204
205#ifdef USE_EVENT
206 void register_event(event::Event *event) { this->events_.push_back(event); }
207#endif
208
209#ifdef USE_UPDATE
210 void register_update(update::UpdateEntity *update) { this->updates_.push_back(update); }
211#endif
212
214
216 template<class C> C *register_component(C *c) {
217 static_assert(std::is_base_of<Component, C>::value, "Only Component subclasses can be registered");
218 this->register_component_((Component *) c);
219 return c;
220 }
221
223 void setup();
224
226 void loop();
227
229 const std::string &get_name() const { return this->name_; }
230
232 const std::string &get_friendly_name() const { return this->friendly_name_; }
233
235 const char *get_area() const {
236#ifdef USE_AREAS
237 // If we have areas registered, return the name of the first one (which is the top-level area)
238 if (!this->areas_.empty() && this->areas_[0] != nullptr) {
239 return this->areas_[0]->get_name();
240 }
241#endif
242 return "";
243 }
244
246 std::string get_comment() const { return this->comment_; }
247
249
250 std::string get_compilation_time() const { return this->compilation_time_; }
251
253 inline uint32_t IRAM_ATTR HOT get_loop_component_start_time() const { return this->loop_component_start_time_; }
254
271 void set_loop_interval(uint32_t loop_interval) {
272 this->loop_interval_ = std::min(loop_interval, static_cast<uint32_t>(std::numeric_limits<uint16_t>::max()));
273 }
274
275 uint32_t get_loop_interval() const { return static_cast<uint32_t>(this->loop_interval_); }
276
278
279 void feed_wdt(uint32_t time = 0);
280
281 void reboot();
282
283 void safe_reboot();
284
286
287 void run_powerdown_hooks();
288
293 void teardown_components(uint32_t timeout_ms);
294
295 uint8_t get_app_state() const { return this->app_state_; }
296
297// Helper macro for entity getter method declarations
298#ifdef USE_DEVICES
299#define GET_ENTITY_METHOD(entity_type, entity_name, entities_member) \
300 entity_type *get_##entity_name##_by_key(uint32_t key, uint32_t device_id, bool include_internal = false) { \
301 for (auto *obj : this->entities_member##_) { \
302 if (obj->get_object_id_hash() == key && obj->get_device_id() == device_id && \
303 (include_internal || !obj->is_internal())) \
304 return obj; \
305 } \
306 return nullptr; \
307 }
308 const auto &get_devices() { return this->devices_; }
309#else
310#define GET_ENTITY_METHOD(entity_type, entity_name, entities_member) \
311 entity_type *get_##entity_name##_by_key(uint32_t key, bool include_internal = false) { \
312 for (auto *obj : this->entities_member##_) { \
313 if (obj->get_object_id_hash() == key && (include_internal || !obj->is_internal())) \
314 return obj; \
315 } \
316 return nullptr; \
317 }
318#endif // USE_DEVICES
319#ifdef USE_AREAS
320 const auto &get_areas() { return this->areas_; }
321#endif
322#ifdef USE_BINARY_SENSOR
323 auto &get_binary_sensors() const { return this->binary_sensors_; }
324 GET_ENTITY_METHOD(binary_sensor::BinarySensor, binary_sensor, binary_sensors)
325#endif
326#ifdef USE_SWITCH
327 auto &get_switches() const { return this->switches_; }
329#endif
330#ifdef USE_BUTTON
331 auto &get_buttons() const { return this->buttons_; }
333#endif
334#ifdef USE_SENSOR
335 auto &get_sensors() const { return this->sensors_; }
337#endif
338#ifdef USE_TEXT_SENSOR
339 auto &get_text_sensors() const { return this->text_sensors_; }
340 GET_ENTITY_METHOD(text_sensor::TextSensor, text_sensor, text_sensors)
341#endif
342#ifdef USE_FAN
343 auto &get_fans() const { return this->fans_; }
345#endif
346#ifdef USE_COVER
347 auto &get_covers() const { return this->covers_; }
349#endif
350#ifdef USE_LIGHT
351 auto &get_lights() const { return this->lights_; }
353#endif
354#ifdef USE_CLIMATE
355 auto &get_climates() const { return this->climates_; }
357#endif
358#ifdef USE_NUMBER
359 auto &get_numbers() const { return this->numbers_; }
361#endif
362#ifdef USE_DATETIME_DATE
363 auto &get_dates() const { return this->dates_; }
365#endif
366#ifdef USE_DATETIME_TIME
367 auto &get_times() const { return this->times_; }
369#endif
370#ifdef USE_DATETIME_DATETIME
371 auto &get_datetimes() const { return this->datetimes_; }
373#endif
374#ifdef USE_TEXT
375 auto &get_texts() const { return this->texts_; }
377#endif
378#ifdef USE_SELECT
379 auto &get_selects() const { return this->selects_; }
381#endif
382#ifdef USE_LOCK
383 auto &get_locks() const { return this->locks_; }
385#endif
386#ifdef USE_VALVE
387 auto &get_valves() const { return this->valves_; }
389#endif
390#ifdef USE_MEDIA_PLAYER
391 auto &get_media_players() const { return this->media_players_; }
392 GET_ENTITY_METHOD(media_player::MediaPlayer, media_player, media_players)
393#endif
394
395#ifdef USE_ALARM_CONTROL_PANEL
396 auto &get_alarm_control_panels() const { return this->alarm_control_panels_; }
397 GET_ENTITY_METHOD(alarm_control_panel::AlarmControlPanel, alarm_control_panel, alarm_control_panels)
398#endif
399
400#ifdef USE_EVENT
401 auto &get_events() const { return this->events_; }
403#endif
404
405#ifdef USE_UPDATE
406 auto &get_updates() const { return this->updates_; }
408#endif
409
410 Scheduler scheduler;
411
413#ifdef USE_SOCKET_SELECT_SUPPORT
418 bool register_socket_fd(int fd);
419 void unregister_socket_fd(int fd);
422 bool is_socket_ready(int fd) const;
423#endif
424
425 protected:
426 friend Component;
427
428 void register_component_(Component *comp);
429
431
432 // These methods are called by Component::disable_loop() and Component::enable_loop()
433 // Components should not call these directly - use this->disable_loop() or this->enable_loop()
434 // to ensure component state is properly updated along with the loop partition
435 void disable_component_loop_(Component *component);
436 void enable_component_loop_(Component *component);
438 void activate_looping_component_(uint16_t index);
439 void before_loop_tasks_(uint32_t loop_start_time);
440 void after_loop_tasks_();
441
443
445 void yield_with_select_(uint32_t delay_ms);
446
447 // === Member variables ordered by size to minimize padding ===
448
449 // Pointer-sized members first
451 const char *comment_{nullptr};
452 const char *compilation_time_{nullptr};
453
454 // std::vector (3 pointers each: begin, end, capacity)
455 // Partitioned vector design for looping components
456 // =================================================
457 // Components are partitioned into [active | inactive] sections:
458 //
459 // looping_components_: [A, B, C, D | E, F]
460 // ^
461 // looping_components_active_end_ (4)
462 //
463 // - Components A,B,C,D are active and will be called in loop()
464 // - Components E,F are inactive (disabled/failed) and won't be called
465 // - No flag checking needed during iteration - just loop 0 to active_end_
466 // - When a component is disabled, it's swapped with the last active component
467 // and active_end_ is decremented
468 // - When a component is enabled, it's swapped with the first inactive component
469 // and active_end_ is incremented
470 // - This eliminates branch mispredictions from flag checking in the hot loop
471 std::vector<Component *> looping_components_{};
472#ifdef USE_SOCKET_SELECT_SUPPORT
473 std::vector<int> socket_fds_; // Vector of all monitored socket file descriptors
474#endif
475
476 // std::string members (typically 24-32 bytes each)
477 std::string name_;
478 std::string friendly_name_;
479
480 // size_t members
481 size_t dump_config_at_{SIZE_MAX};
482
483 // 4-byte members
484 uint32_t last_loop_{0};
486
487#ifdef USE_SOCKET_SELECT_SUPPORT
488 int max_fd_{-1}; // Highest file descriptor number for select()
489#endif
490
491 // 2-byte members (grouped together for alignment)
492 uint16_t loop_interval_{16}; // Loop interval in ms (max 65535ms = 65.5 seconds)
493 uint16_t looping_components_active_end_{0}; // Index marking end of active components in looping_components_
494 uint16_t current_loop_index_{0}; // For safe reentrant modifications during iteration
495
496 // 1-byte members (grouped together to minimize padding)
497 uint8_t app_state_{0};
499 bool in_loop_{false};
501
502#ifdef USE_SOCKET_SELECT_SUPPORT
503 bool socket_fds_changed_{false}; // Flag to rebuild base_read_fds_ when socket_fds_ changes
504#endif
505
506#ifdef USE_SOCKET_SELECT_SUPPORT
507 // Variable-sized members
508 fd_set base_read_fds_{}; // Cached fd_set rebuilt only when socket_fds_ changes
509 fd_set read_fds_{}; // Working fd_set for select(), copied from base_read_fds_
510#endif
511
512 // StaticVectors (largest members - contain actual array data inline)
514
515#ifdef USE_DEVICES
517#endif
518#ifdef USE_AREAS
520#endif
521#ifdef USE_BINARY_SENSOR
523#endif
524#ifdef USE_SWITCH
526#endif
527#ifdef USE_BUTTON
529#endif
530#ifdef USE_EVENT
532#endif
533#ifdef USE_SENSOR
535#endif
536#ifdef USE_TEXT_SENSOR
538#endif
539#ifdef USE_FAN
541#endif
542#ifdef USE_COVER
544#endif
545#ifdef USE_CLIMATE
547#endif
548#ifdef USE_LIGHT
550#endif
551#ifdef USE_NUMBER
553#endif
554#ifdef USE_DATETIME_DATE
556#endif
557#ifdef USE_DATETIME_TIME
559#endif
560#ifdef USE_DATETIME_DATETIME
562#endif
563#ifdef USE_SELECT
565#endif
566#ifdef USE_TEXT
568#endif
569#ifdef USE_LOCK
571#endif
572#ifdef USE_VALVE
574#endif
575#ifdef USE_MEDIA_PLAYER
577#endif
578#ifdef USE_ALARM_CONTROL_PANEL
581#endif
582#ifdef USE_UPDATE
584#endif
585};
586
588extern Application App; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
589
590} // namespace esphome
StaticVector< switch_::Switch *, ESPHOME_ENTITY_SWITCH_COUNT > switches_
StaticVector< light::LightState *, ESPHOME_ENTITY_LIGHT_COUNT > lights_
void setup()
Set up all the registered components. Call this at the end of your setup() function.
uint32_t get_loop_interval() const
StaticVector< valve::Valve *, ESPHOME_ENTITY_VALVE_COUNT > valves_
std::string get_comment() const
Get the comment of this Application set by pre_setup().
void register_fan(fan::Fan *state)
void register_button(button::Button *button)
GET_ENTITY_METHOD(select::Select, select, selects) auto &get_locks() const
const std::string & get_friendly_name() const
Get the friendly name of this Application set by pre_setup().
StaticVector< datetime::TimeEntity *, ESPHOME_ENTITY_TIME_COUNT > times_
GET_ENTITY_METHOD(fan::Fan, fan, fans) auto &get_covers() const
void register_light(light::LightState *light)
const auto & get_areas()
void register_binary_sensor(binary_sensor::BinarySensor *binary_sensor)
void pre_setup(const std::string &name, const std::string &friendly_name, const char *comment, const char *compilation_time, bool name_add_mac_suffix)
Definition application.h:99
uint16_t looping_components_active_end_
void set_current_component(Component *component)
Component * get_current_component()
StaticVector< binary_sensor::BinarySensor *, ESPHOME_ENTITY_BINARY_SENSOR_COUNT > binary_sensors_
bool is_socket_ready(int fd) const
Check if there's data available on a socket without blocking This function is thread-safe for reading...
void register_alarm_control_panel(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel)
GET_ENTITY_METHOD(datetime::TimeEntity, time, times) auto &get_datetimes() const
StaticVector< select::Select *, ESPHOME_ENTITY_SELECT_COUNT > selects_
GET_ENTITY_METHOD(climate::Climate, climate, climates) auto &get_numbers() const
void register_update(update::UpdateEntity *update)
StaticVector< Area *, ESPHOME_AREA_COUNT > areas_
void register_media_player(media_player::MediaPlayer *media_player)
GET_ENTITY_METHOD(valve::Valve, valve, valves) auto &get_media_players() const
StaticVector< fan::Fan *, ESPHOME_ENTITY_FAN_COUNT > fans_
std::vector< int > socket_fds_
void register_number(number::Number *number)
GET_ENTITY_METHOD(update::UpdateEntity, update, updates) Scheduler scheduler
void set_loop_interval(uint32_t loop_interval)
Set the target interval with which to run the loop() calls.
StaticVector< Component *, ESPHOME_COMPONENT_COUNT > components_
void register_climate(climate::Climate *climate)
StaticVector< datetime::DateEntity *, ESPHOME_ENTITY_DATE_COUNT > dates_
void register_cover(cover::Cover *cover)
StaticVector< media_player::MediaPlayer *, ESPHOME_ENTITY_MEDIA_PLAYER_COUNT > media_players_
GET_ENTITY_METHOD(text::Text, text, texts) auto &get_selects() const
std::string get_compilation_time() const
StaticVector< update::UpdateEntity *, ESPHOME_ENTITY_UPDATE_COUNT > updates_
void register_area(Area *area)
Component * current_component_
GET_ENTITY_METHOD(datetime::DateEntity, date, dates) auto &get_times() const
void register_datetime(datetime::DateTimeEntity *datetime)
GET_ENTITY_METHOD(light::LightState, light, lights) auto &get_climates() const
void register_time(datetime::TimeEntity *time)
void enable_component_loop_(Component *component)
uint32_t loop_component_start_time_
GET_ENTITY_METHOD(media_player::MediaPlayer, media_player, media_players) auto &get_alarm_control_panels() const
StaticVector< climate::Climate *, ESPHOME_ENTITY_CLIMATE_COUNT > climates_
GET_ENTITY_METHOD(text_sensor::TextSensor, text_sensor, text_sensors) auto &get_fans() const
void disable_component_loop_(Component *component)
const char * comment_
const char * get_area() const
Get the area of this Application set by pre_setup().
bool is_name_add_mac_suffix_enabled() const
void activate_looping_component_(uint16_t index)
const auto & get_devices()
StaticVector< cover::Cover *, ESPHOME_ENTITY_COVER_COUNT > covers_
StaticVector< lock::Lock *, ESPHOME_ENTITY_LOCK_COUNT > locks_
std::string friendly_name_
void register_switch(switch_::Switch *a_switch)
const std::string & get_name() const
Get the name of this Application set by pre_setup().
void register_lock(lock::Lock *a_lock)
StaticVector< event::Event *, ESPHOME_ENTITY_EVENT_COUNT > events_
void teardown_components(uint32_t timeout_ms)
Teardown all components with a timeout.
void register_event(event::Event *event)
void register_valve(valve::Valve *valve)
void register_sensor(sensor::Sensor *sensor)
StaticVector< alarm_control_panel::AlarmControlPanel *, ESPHOME_ENTITY_ALARM_CONTROL_PANEL_COUNT > alarm_control_panels_
volatile bool has_pending_enable_loop_requests_
GET_ENTITY_METHOD(datetime::DateTimeEntity, datetime, datetimes) auto &get_texts() const
GET_ENTITY_METHOD(sensor::Sensor, sensor, sensors) auto &get_text_sensors() const
StaticVector< text_sensor::TextSensor *, ESPHOME_ENTITY_TEXT_SENSOR_COUNT > text_sensors_
const char * compilation_time_
StaticVector< datetime::DateTimeEntity *, ESPHOME_ENTITY_DATETIME_COUNT > datetimes_
std::vector< Component * > looping_components_
GET_ENTITY_METHOD(switch_::Switch, switch, switches) auto &get_buttons() const
GET_ENTITY_METHOD(binary_sensor::BinarySensor, binary_sensor, binary_sensors) auto &get_switches() const
void register_text_sensor(text_sensor::TextSensor *sensor)
uint16_t current_loop_index_
StaticVector< button::Button *, ESPHOME_ENTITY_BUTTON_COUNT > buttons_
GET_ENTITY_METHOD(alarm_control_panel::AlarmControlPanel, alarm_control_panel, alarm_control_panels) auto &get_events() const
StaticVector< text::Text *, ESPHOME_ENTITY_TEXT_COUNT > texts_
void register_select(select::Select *select)
void feed_wdt(uint32_t time=0)
C * register_component(C *c)
Reserve space for components to avoid memory fragmentation.
void before_loop_tasks_(uint32_t loop_start_time)
void loop()
Make a loop iteration. Call this in your loop() function.
void register_text(text::Text *text)
void register_device(Device *device)
void unregister_socket_fd(int fd)
GET_ENTITY_METHOD(event::Event, event, events) auto &get_updates() const
GET_ENTITY_METHOD(cover::Cover, cover, covers) auto &get_lights() const
bool register_socket_fd(int fd)
Register/unregister a socket file descriptor to be monitored for read events.
StaticVector< Device *, ESPHOME_DEVICE_COUNT > devices_
StaticVector< number::Number *, ESPHOME_ENTITY_NUMBER_COUNT > numbers_
void calculate_looping_components_()
auto & get_binary_sensors() const
uint32_t IRAM_ATTR HOT get_loop_component_start_time() const
Get the cached time in milliseconds from when the current component started its loop execution.
void yield_with_select_(uint32_t delay_ms)
Perform a delay while also monitoring socket file descriptors for readiness.
uint8_t get_app_state() const
GET_ENTITY_METHOD(number::Number, number, numbers) auto &get_dates() const
GET_ENTITY_METHOD(lock::Lock, lock, locks) auto &get_valves() const
StaticVector< sensor::Sensor *, ESPHOME_ENTITY_SENSOR_COUNT > sensors_
GET_ENTITY_METHOD(button::Button, button, buttons) auto &get_sensors() const
void register_component_(Component *comp)
void register_date(datetime::DateEntity *date)
Minimal static vector - saves memory by avoiding std::vector overhead.
Definition helpers.h:99
Base class for all binary_sensor-type classes.
Base class for all buttons.
Definition button.h:29
ClimateDevice - This is the base class for all climate integrations.
Definition climate.h:168
Base class for all cover devices.
Definition cover.h:111
This class represents the communication layer between the front-end MQTT layer and the hardware outpu...
Definition light_state.h:66
Base class for all locks.
Definition lock.h:103
Base-class for all numbers.
Definition number.h:39
Base-class for all selects.
Definition select.h:31
Base-class for all sensors.
Definition sensor.h:59
Base class for all switches.
Definition switch.h:39
Base-class for all text inputs.
Definition text.h:24
Base class for all valve devices.
Definition valve.h:105
bool state
Definition fan.h:0
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
void arch_init()
Definition core.cpp:40
std::string get_mac_address()
Get the device MAC address as a string, in lowercase hex notation.
Definition helpers.cpp:578
Application App
Global storage of Application pointer - only one Application can exist.