Squashed 'pomodoro/' changes from d3299783c..b4087037b

b4087037b fix catalog versions
2f006baa2 bump version
e4d9959cf Update apps
7bfa94dba bump versions
5cee3bd7c fix cnt down timer & update pomodoro
793f8fa80 categories part 1
63f561c85 more manifestos, xbox controller and videopoker ufbt fixes
a7b41b1fe Add Screenshots
0a1b42c4d API 31 / unzip sources
REVERT: d3299783c feat: on-demand contextual chatting (#211)
REVERT: 52cc11a8c feat: display stats (#97)
REVERT: ddda80fc1 ci(build): fix missing deed method (#198)
REVERT: 2f2962d96 feat: long cycle (#42) (#45)
REVERT: 925ebc645 feat: animated stage background (#39)(#32)
REVERT: 70e3a7168 refactor: modules structure (#11)
REVERT: fa6358214 feat: add happiness management (#10)
REVERT: 57b148772 update images art
REVERT: 621c6fddd complete MVP
REVERT: b3f442d00 add timer stage toggl
REVERT: f49e1722d add build infrastructure

git-subtree-dir: pomodoro
git-subtree-split: b4087037bc46fba226c789d77b701ba43adbbff0

application.fam

@@ -5,7 +5,11 @@ App(
     entry_point="flipp_pomodoro_app",
     requires=["gui", "notification", "dolphin"],
     stack_size=1 * 1024,
-    fap_category="Productivity",
+    fap_category="Tools",
     fap_icon_assets="images",
     fap_icon="flipp_pomodoro_10.png",
+    fap_author="@Th3Un1q3",
+    fap_weburl="https://github.com/Th3Un1q3/flipp_pomodoro",
+    fap_version="1.3",
+    fap_description="Boost Your Productivity with the Pomodoro Timer",
 )

flipp_pomodoro_app.c

@@ -2,43 +2,36 @@
 
 #define TAG "FlippPomodoro"
 
-enum
-{
+enum {
     CustomEventConsumed = true,
     CustomEventNotConsumed = false,
 };
 
-static bool flipp_pomodoro_app_back_event_callback(void *ctx)
-{
+static bool flipp_pomodoro_app_back_event_callback(void* ctx) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
     return scene_manager_handle_back_event(app->scene_manager);
 };
 
-static void flipp_pomodoro_app_tick_event_callback(void *ctx)
-{
+static void flipp_pomodoro_app_tick_event_callback(void* ctx) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
     scene_manager_handle_custom_event(app->scene_manager, FlippPomodoroAppCustomEventTimerTick);
 };
 
-static bool flipp_pomodoro_app_custom_event_callback(void *ctx, uint32_t event)
-{
+static bool flipp_pomodoro_app_custom_event_callback(void* ctx, uint32_t event) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
-    switch (event)
-    {
+    switch(event) {
     case FlippPomodoroAppCustomEventStageSkip:
         flipp_pomodoro__toggle_stage(app->state);
         view_dispatcher_send_custom_event(
-            app->view_dispatcher,
-            FlippPomodoroAppCustomEventStateUpdated);
+            app->view_dispatcher, FlippPomodoroAppCustomEventStateUpdated);
         return CustomEventConsumed;
     case FlippPomodoroAppCustomEventStageComplete:
-        if (flipp_pomodoro__get_stage(app->state) == FlippPomodoroStageFocus)
-        {
+        if(flipp_pomodoro__get_stage(app->state) == FlippPomodoroStageFocus) {
             // REGISTER a deed on work stage complete to get an acheivement
             dolphin_deed(DolphinDeedPluginGameWin);
             FURI_LOG_I(TAG, "Focus stage reward added");
@@ -47,10 +40,11 @@ static bool flipp_pomodoro_app_custom_event_callback(void *ctx, uint32_t event)
         };
 
         flipp_pomodoro__toggle_stage(app->state);
-        notification_message(app->notification_app, stage_start_notification_sequence_map[flipp_pomodoro__get_stage(app->state)]);
+        notification_message(
+            app->notification_app,
+            stage_start_notification_sequence_map[flipp_pomodoro__get_stage(app->state)]);
         view_dispatcher_send_custom_event(
-            app->view_dispatcher,
-            FlippPomodoroAppCustomEventStateUpdated);
+            app->view_dispatcher, FlippPomodoroAppCustomEventStateUpdated);
         return CustomEventConsumed;
     default:
         break;
@@ -58,9 +52,8 @@ static bool flipp_pomodoro_app_custom_event_callback(void *ctx, uint32_t event)
     return scene_manager_handle_custom_event(app->scene_manager, event);
 };
 
-FlippPomodoroApp *flipp_pomodoro_app_alloc()
-{
-    FlippPomodoroApp *app = malloc(sizeof(FlippPomodoroApp));
+FlippPomodoroApp* flipp_pomodoro_app_alloc() {
+    FlippPomodoroApp* app = malloc(sizeof(FlippPomodoroApp));
     app->state = flipp_pomodoro__new();
 
     app->scene_manager = scene_manager_alloc(&flipp_pomodoro_scene_handlers, app);
@@ -72,10 +65,13 @@ FlippPomodoroApp *flipp_pomodoro_app_alloc()
 
     view_dispatcher_enable_queue(app->view_dispatcher);
     view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
-    view_dispatcher_set_custom_event_callback(app->view_dispatcher, flipp_pomodoro_app_custom_event_callback);
-    view_dispatcher_set_tick_event_callback(app->view_dispatcher, flipp_pomodoro_app_tick_event_callback, 1000);
+    view_dispatcher_set_custom_event_callback(
+        app->view_dispatcher, flipp_pomodoro_app_custom_event_callback);
+    view_dispatcher_set_tick_event_callback(
+        app->view_dispatcher, flipp_pomodoro_app_tick_event_callback, 1000);
     view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
-    view_dispatcher_set_navigation_event_callback(app->view_dispatcher, flipp_pomodoro_app_back_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        app->view_dispatcher, flipp_pomodoro_app_back_event_callback);
 
     app->timer_view = flipp_pomodoro_view_timer_alloc();
     app->info_view = flipp_pomodoro_info_view_alloc();
@@ -95,8 +91,7 @@ FlippPomodoroApp *flipp_pomodoro_app_alloc()
     return app;
 };
 
-void flipp_pomodoro_app_free(FlippPomodoroApp *app)
-{
+void flipp_pomodoro_app_free(FlippPomodoroApp* app) {
     view_dispatcher_remove_view(app->view_dispatcher, FlippPomodoroAppViewTimer);
     view_dispatcher_remove_view(app->view_dispatcher, FlippPomodoroAppViewInfo);
     view_dispatcher_free(app->view_dispatcher);
@@ -110,11 +105,10 @@ void flipp_pomodoro_app_free(FlippPomodoroApp *app)
     furi_record_close(RECORD_NOTIFICATION);
 };
 
-int32_t flipp_pomodoro_app(void *p)
-{
+int32_t flipp_pomodoro_app(void* p) {
     UNUSED(p);
     FURI_LOG_I(TAG, "Initial");
-    FlippPomodoroApp *app = flipp_pomodoro_app_alloc();
+    FlippPomodoroApp* app = flipp_pomodoro_app_alloc();
 
     FURI_LOG_I(TAG, "Run deed added");
     dolphin_deed(DolphinDeedPluginGameStart);

flipp_pomodoro_app.h

@@ -12,8 +12,7 @@
 #include "modules/flipp_pomodoro.h"
 #include "modules/flipp_pomodoro_statistics.h"
 
-typedef enum
-{
+typedef enum {
     // Reserve first 100 events for button types and indexes, starting from 0
     FlippPomodoroAppCustomEventStageSkip = 100,
     FlippPomodoroAppCustomEventStageComplete, // By Expiration
@@ -23,20 +22,18 @@ typedef enum
     FlippPomodoroAppCustomEventResumeTimer,
 } FlippPomodoroAppCustomEvent;
 
-typedef struct
-{
-    SceneManager *scene_manager;
-    ViewDispatcher *view_dispatcher;
-    Gui *gui;
-    NotificationApp *notification_app;
-    FlippPomodoroTimerView *timer_view;
-    FlippPomodoroInfoView *info_view;
-    FlippPomodoroState *state;
-    FlippPomodoroStatistics *statistics;
+typedef struct {
+    SceneManager* scene_manager;
+    ViewDispatcher* view_dispatcher;
+    Gui* gui;
+    NotificationApp* notification_app;
+    FlippPomodoroTimerView* timer_view;
+    FlippPomodoroInfoView* info_view;
+    FlippPomodoroState* state;
+    FlippPomodoroStatistics* statistics;
 } FlippPomodoroApp;
 
-typedef enum
-{
+typedef enum {
     FlippPomodoroAppViewTimer,
     FlippPomodoroAppViewInfo,
 } FlippPomodoroAppView;

helpers/notifications.h

@@ -7,7 +7,7 @@ extern const NotificationSequence work_start_notification;
 extern const NotificationSequence rest_start_notification;
 
 /// @brief Defines a notification sequence that should indicate start of specific pomodoro stage.
-const NotificationSequence *stage_start_notification_sequence_map[] = {
+const NotificationSequence* stage_start_notification_sequence_map[] = {
     [FlippPomodoroStageFocus] = &work_start_notification,
     [FlippPomodoroStageRest] = &rest_start_notification,
     [FlippPomodoroStageLongBreak] = &rest_start_notification,

helpers/time.c

@@ -5,17 +5,16 @@
 const int TIME_SECONDS_IN_MINUTE = 60;
 const int TIME_MINUTES_IN_HOUR = 60;
 
-uint32_t time_now()
-{
+uint32_t time_now() {
     return furi_hal_rtc_get_timestamp();
 };
 
-TimeDifference time_difference_seconds(uint32_t begin, uint32_t end)
-{
+TimeDifference time_difference_seconds(uint32_t begin, uint32_t end) {
     const uint32_t duration_seconds = end - begin;
 
     uint32_t minutes = (duration_seconds / TIME_MINUTES_IN_HOUR) % TIME_MINUTES_IN_HOUR;
     uint32_t seconds = duration_seconds % TIME_SECONDS_IN_MINUTE;
 
-    return (TimeDifference){.total_seconds = duration_seconds, .minutes = minutes, .seconds = seconds};
+    return (
+        TimeDifference){.total_seconds = duration_seconds, .minutes = minutes, .seconds = seconds};
 };

helpers/time.h

@@ -7,8 +7,7 @@ extern const int TIME_SECONDS_IN_MINUTE;
 extern const int TIME_MINUTES_IN_HOUR;
 
 /// @brief Container for a time period
-typedef struct
-{
+typedef struct {
     uint8_t seconds;
     uint8_t minutes;
     uint32_t total_seconds;

modules/flipp_pomodoro.c

@@ -17,13 +17,13 @@ PomodoroStage stages_sequence[] = {
     FlippPomodoroStageLongBreak,
 };
 
-char *current_stage_label[] = {
+char* current_stage_label[] = {
     [FlippPomodoroStageFocus] = "Focusing...",
     [FlippPomodoroStageRest] = "Short Break...",
     [FlippPomodoroStageLongBreak] = "Long Break...",
 };
 
-char *next_stage_label[] = {
+char* next_stage_label[] = {
     [FlippPomodoroStageFocus] = "Focus",
     [FlippPomodoroStageRest] = "Short Break",
     [FlippPomodoroStageLongBreak] = "Long Break",
@@ -34,39 +34,33 @@ PomodoroStage flipp_pomodoro__stage_by_index(int index) {
     return stages_sequence[index % one_loop_size];
 }
 
-void flipp_pomodoro__toggle_stage(FlippPomodoroState *state)
-{
+void flipp_pomodoro__toggle_stage(FlippPomodoroState* state) {
     furi_assert(state);
     state->current_stage_index = state->current_stage_index + 1;
     state->started_at_timestamp = time_now();
 };
 
-PomodoroStage flipp_pomodoro__get_stage(FlippPomodoroState *state)
-{
+PomodoroStage flipp_pomodoro__get_stage(FlippPomodoroState* state) {
     furi_assert(state);
     return flipp_pomodoro__stage_by_index(state->current_stage_index);
 };
 
-char *flipp_pomodoro__current_stage_label(FlippPomodoroState *state)
-{
+char* flipp_pomodoro__current_stage_label(FlippPomodoroState* state) {
     furi_assert(state);
     return current_stage_label[flipp_pomodoro__get_stage(state)];
 };
 
-char *flipp_pomodoro__next_stage_label(FlippPomodoroState *state)
-{
+char* flipp_pomodoro__next_stage_label(FlippPomodoroState* state) {
     furi_assert(state);
     return next_stage_label[flipp_pomodoro__stage_by_index(state->current_stage_index + 1)];
 };
 
-void flipp_pomodoro__destroy(FlippPomodoroState *state)
-{
+void flipp_pomodoro__destroy(FlippPomodoroState* state) {
     furi_assert(state);
     free(state);
 };
 
-uint32_t flipp_pomodoro__current_stage_total_duration(FlippPomodoroState *state)
-{
+uint32_t flipp_pomodoro__current_stage_total_duration(FlippPomodoroState* state) {
     const int32_t stage_duration_seconds_map[] = {
         [FlippPomodoroStageFocus] = 25 * TIME_SECONDS_IN_MINUTE,
         [FlippPomodoroStageRest] = 5 * TIME_SECONDS_IN_MINUTE,
@@ -76,27 +70,23 @@ uint32_t flipp_pomodoro__current_stage_total_duration(FlippPomodoroState *state)
     return stage_duration_seconds_map[flipp_pomodoro__get_stage(state)];
 };
 
-uint32_t flipp_pomodoro__stage_expires_timestamp(FlippPomodoroState *state)
-{
+uint32_t flipp_pomodoro__stage_expires_timestamp(FlippPomodoroState* state) {
     return state->started_at_timestamp + flipp_pomodoro__current_stage_total_duration(state);
 };
 
-TimeDifference flipp_pomodoro__stage_remaining_duration(FlippPomodoroState *state)
-{
+TimeDifference flipp_pomodoro__stage_remaining_duration(FlippPomodoroState* state) {
     const uint32_t stage_ends_at = flipp_pomodoro__stage_expires_timestamp(state);
     return time_difference_seconds(time_now(), stage_ends_at);
 };
 
-bool flipp_pomodoro__is_stage_expired(FlippPomodoroState *state)
-{
+bool flipp_pomodoro__is_stage_expired(FlippPomodoroState* state) {
     const uint32_t expired_by = flipp_pomodoro__stage_expires_timestamp(state);
     const uint8_t seamless_change_span_seconds = 1;
     return (time_now() - seamless_change_span_seconds) >= expired_by;
 };
 
-FlippPomodoroState *flipp_pomodoro__new()
-{
-    FlippPomodoroState *state = malloc(sizeof(FlippPomodoroState));
+FlippPomodoroState* flipp_pomodoro__new() {
+    FlippPomodoroState* state = malloc(sizeof(FlippPomodoroState));
     const uint32_t now = time_now();
     state->started_at_timestamp = now;
     state->current_stage_index = 0;

modules/flipp_pomodoro.h

@@ -4,52 +4,50 @@
 #include "../helpers/time.h"
 
 /// @brief Options of pomodoro stages
-typedef enum
-{
+typedef enum {
     FlippPomodoroStageFocus,
     FlippPomodoroStageRest,
     FlippPomodoroStageLongBreak,
 } PomodoroStage;
 
 /// @brief State of the pomodoro timer
-typedef struct
-{
+typedef struct {
     uint8_t current_stage_index;
     uint32_t started_at_timestamp;
 } FlippPomodoroState;
 
 /// @brief Generates initial state
 /// @returns A new pre-populated state for pomodoro timer
-FlippPomodoroState *flipp_pomodoro__new();
+FlippPomodoroState* flipp_pomodoro__new();
 
 /// @brief Extract current stage of pomodoro
 /// @param state - pointer to the state of pomorodo
 /// @returns Current stage value
-PomodoroStage flipp_pomodoro__get_stage(FlippPomodoroState *state);
+PomodoroStage flipp_pomodoro__get_stage(FlippPomodoroState* state);
 
 /// @brief Destroys state of timer and it's dependencies
-void flipp_pomodoro__destroy(FlippPomodoroState *state);
+void flipp_pomodoro__destroy(FlippPomodoroState* state);
 
 /// @brief Get remaining stage time.
 /// @param state - pointer to the state of pomorodo
 /// @returns Time difference to the end of current stage
-TimeDifference flipp_pomodoro__stage_remaining_duration(FlippPomodoroState *state);
+TimeDifference flipp_pomodoro__stage_remaining_duration(FlippPomodoroState* state);
 
 /// @brief Label of currently active stage
 /// @param state - pointer to the state of pomorodo
 /// @returns A string that explains current stage
-char *flipp_pomodoro__current_stage_label(FlippPomodoroState *state);
+char* flipp_pomodoro__current_stage_label(FlippPomodoroState* state);
 
 /// @brief Label of transition to the next stage
 /// @param state - pointer to the state of pomorodo.
 /// @returns string with the label of the "skipp" button
-char *flipp_pomodoro__next_stage_label(FlippPomodoroState *state);
+char* flipp_pomodoro__next_stage_label(FlippPomodoroState* state);
 
 /// @brief Check if current stage is expired
 /// @param state - pointer to the state of pomorodo.
 /// @returns expriations status - true means stage is expired
-bool flipp_pomodoro__is_stage_expired(FlippPomodoroState *state);
+bool flipp_pomodoro__is_stage_expired(FlippPomodoroState* state);
 
 /// @brief Rotate stage of the timer
 /// @param state - pointer to the state of pomorodo.
-void flipp_pomodoro__toggle_stage(FlippPomodoroState *state);
+void flipp_pomodoro__toggle_stage(FlippPomodoroState* state);

modules/flipp_pomodoro_statistics.c

@@ -1,8 +1,7 @@
 #include "flipp_pomodoro_statistics.h"
 
-FlippPomodoroStatistics *flipp_pomodoro_statistics__new()
-{
-    FlippPomodoroStatistics *statistics = malloc(sizeof(FlippPomodoroStatistics));
+FlippPomodoroStatistics* flipp_pomodoro_statistics__new() {
+    FlippPomodoroStatistics* statistics = malloc(sizeof(FlippPomodoroStatistics));
 
     statistics->focus_stages_completed = 0;
 
@@ -10,19 +9,18 @@ FlippPomodoroStatistics *flipp_pomodoro_statistics__new()
 }
 
 // Return the number of completed focus stages
-uint8_t flipp_pomodoro_statistics__get_focus_stages_completed(FlippPomodoroStatistics *statistics)
-{
+uint8_t
+    flipp_pomodoro_statistics__get_focus_stages_completed(FlippPomodoroStatistics* statistics) {
     return statistics->focus_stages_completed;
 }
 
 // Increase the number of completed focus stages by one
-void flipp_pomodoro_statistics__increase_focus_stages_completed(FlippPomodoroStatistics *statistics)
-{
+void flipp_pomodoro_statistics__increase_focus_stages_completed(
+    FlippPomodoroStatistics* statistics) {
     statistics->focus_stages_completed++;
 }
 
-void flipp_pomodoro_statistics__destroy(FlippPomodoroStatistics *statistics)
-{
+void flipp_pomodoro_statistics__destroy(FlippPomodoroStatistics* statistics) {
     furi_assert(statistics);
     free(statistics);
 };

modules/flipp_pomodoro_statistics.h

@@ -5,8 +5,7 @@
  *
  *  This structure is used to keep track of completed focus stages.
  */
-typedef struct
-{
+typedef struct {
     uint8_t focus_stages_completed;
 } FlippPomodoroStatistics;
 
@@ -17,7 +16,7 @@ typedef struct
  *
  *  @return A pointer to a new FlippPomodoroStatistics structure
  */
-FlippPomodoroStatistics *flipp_pomodoro_statistics__new();
+FlippPomodoroStatistics* flipp_pomodoro_statistics__new();
 
 /** @brief Get the number of completed focus stages
  *
@@ -26,7 +25,7 @@ FlippPomodoroStatistics *flipp_pomodoro_statistics__new();
  *  @param statistics A pointer to a FlippPomodoroStatistics structure
  *  @return The number of completed focus stages
  */
-uint8_t flipp_pomodoro_statistics__get_focus_stages_completed(FlippPomodoroStatistics *statistics);
+uint8_t flipp_pomodoro_statistics__get_focus_stages_completed(FlippPomodoroStatistics* statistics);
 
 /** @brief Increase the number of completed focus stages
  *
@@ -34,7 +33,8 @@ uint8_t flipp_pomodoro_statistics__get_focus_stages_completed(FlippPomodoroStati
  *
  *  @param statistics A pointer to a FlippPomodoroStatistics structure
  */
-void flipp_pomodoro_statistics__increase_focus_stages_completed(FlippPomodoroStatistics *statistics);
+void flipp_pomodoro_statistics__increase_focus_stages_completed(
+    FlippPomodoroStatistics* statistics);
 
 /** @brief Free a FlippPomodoroStatistics structure
  *
@@ -42,4 +42,4 @@ void flipp_pomodoro_statistics__increase_focus_stages_completed(FlippPomodoroSta
  *
  *  @param statistics A pointer to a FlippPomodoroStatistics structure
  */
-void flipp_pomodoro_statistics__destroy(FlippPomodoroStatistics *state);
+void flipp_pomodoro_statistics__destroy(FlippPomodoroStatistics* state);

scenes/flipp_pomodoro_scene.h

@@ -3,8 +3,7 @@
 
 // Generate scene id and total number
 #define ADD_SCENE(prefix, name, id) FlippPomodoroScene##id,
-typedef enum
-{
+typedef enum {
 #include "config/flipp_pomodoro_scene_config.h"
     FlippPomodoroSceneNum,
 } FlippPomodoroScene;
@@ -13,17 +12,17 @@ typedef enum
 extern const SceneManagerHandlers flipp_pomodoro_scene_handlers;
 
 // Generate scene on_enter handlers declaration
-#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void *);
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
 #include "config/flipp_pomodoro_scene_config.h"
 #undef ADD_SCENE
 
 // Generate scene on_event handlers declaration
 #define ADD_SCENE(prefix, name, id) \
-    bool prefix##_scene_##name##_on_event(void *ctx, SceneManagerEvent event);
+    bool prefix##_scene_##name##_on_event(void* ctx, SceneManagerEvent event);
 #include "config/flipp_pomodoro_scene_config.h"
 #undef ADD_SCENE
 
 // Generate scene on_exit handlers declaration
-#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void *ctx);
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* ctx);
 #include "config/flipp_pomodoro_scene_config.h"
 #undef ADD_SCENE

scenes/flipp_pomodoro_scene_info.c

@@ -5,50 +5,43 @@
 #include "../flipp_pomodoro_app.h"
 #include "../views/flipp_pomodoro_info_view.h"
 
-enum
-{
-    SceneEventConusmed = true,
-    SceneEventNotConusmed = false
-};
+enum { SceneEventConusmed = true, SceneEventNotConusmed = false };
 
-void flipp_pomodoro_scene_info_on_back_to_timer(void *ctx)
-{
+void flipp_pomodoro_scene_info_on_back_to_timer(void* ctx) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
     view_dispatcher_send_custom_event(
-        app->view_dispatcher,
-        FlippPomodoroAppCustomEventResumeTimer);
+        app->view_dispatcher, FlippPomodoroAppCustomEventResumeTimer);
 };
 
-void flipp_pomodoro_scene_info_on_enter(void *ctx)
-{
+void flipp_pomodoro_scene_info_on_enter(void* ctx) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
     view_dispatcher_switch_to_view(app->view_dispatcher, FlippPomodoroAppViewInfo);
     flipp_pomodoro_info_view_set_pomodoros_completed(
         flipp_pomodoro_info_view_get_view(app->info_view),
         flipp_pomodoro_statistics__get_focus_stages_completed(app->statistics));
-    flipp_pomodoro_info_view_set_mode(flipp_pomodoro_info_view_get_view(app->info_view), FlippPomodoroInfoViewModeStats);
-    flipp_pomodoro_info_view_set_resume_timer_cb(app->info_view, flipp_pomodoro_scene_info_on_back_to_timer, app);
+    flipp_pomodoro_info_view_set_mode(
+        flipp_pomodoro_info_view_get_view(app->info_view), FlippPomodoroInfoViewModeStats);
+    flipp_pomodoro_info_view_set_resume_timer_cb(
+        app->info_view, flipp_pomodoro_scene_info_on_back_to_timer, app);
 };
 
-void flipp_pomodoro_scene_info_handle_custom_event(FlippPomodoroApp *app, FlippPomodoroAppCustomEvent custom_event)
-{
-    if (custom_event == FlippPomodoroAppCustomEventResumeTimer)
-    {
+void flipp_pomodoro_scene_info_handle_custom_event(
+    FlippPomodoroApp* app,
+    FlippPomodoroAppCustomEvent custom_event) {
+    if(custom_event == FlippPomodoroAppCustomEventResumeTimer) {
         scene_manager_next_scene(app->scene_manager, FlippPomodoroSceneTimer);
     }
 };
 
-bool flipp_pomodoro_scene_info_on_event(void *ctx, SceneManagerEvent event)
-{
+bool flipp_pomodoro_scene_info_on_event(void* ctx, SceneManagerEvent event) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
-    switch (event.type)
-    {
+    switch(event.type) {
     case SceneManagerEventTypeBack:
         view_dispatcher_stop(app->view_dispatcher);
         return SceneEventConusmed;
@@ -61,7 +54,6 @@ bool flipp_pomodoro_scene_info_on_event(void *ctx, SceneManagerEvent event)
     return SceneEventNotConusmed;
 };
 
-void flipp_pomodoro_scene_info_on_exit(void *ctx)
-{
+void flipp_pomodoro_scene_info_on_exit(void* ctx) {
     UNUSED(ctx);
 };

scenes/flipp_pomodoro_scene_timer.c

@@ -6,13 +6,9 @@
 #include "../flipp_pomodoro_app.h"
 #include "../views/flipp_pomodoro_timer_view.h"
 
-enum
-{
-    SceneEventConusmed = true,
-    SceneEventNotConusmed = false
-};
+enum { SceneEventConusmed = true, SceneEventNotConusmed = false };
 
-static char *work_hints[] = {
+static char* work_hints[] = {
     "Can you explain the problem as if I'm five?",
     "Expected output vs. reality: what's the difference?",
     "Ever thought of slicing the problem into bite-sized pieces?",
@@ -31,7 +27,7 @@ static char *work_hints[] = {
     "What if you take a different path to solve this?",
     "Did you take a coffee break to reboot your brain?"};
 
-static char *break_hints[] = {
+static char* break_hints[] = {
     "Time to stretch! Remember, your body isn't made of code.",
     "Hydrate or diedrate! Grab a glass of water.",
     "Blink! Your eyes need a break too.",
@@ -50,50 +46,40 @@ static char *break_hints[] = {
     "Ever tried juggling? Now's your chance!",
     "Do a quick self high-five, you're doing great!"};
 
-static char *random_string_of_list(char **hints, size_t num_hints)
-{
+static char* random_string_of_list(char** hints, size_t num_hints) {
     int random_index = rand() % num_hints;
     return hints[random_index];
 }
 
-void flipp_pomodoro_scene_timer_sync_view_state(void *ctx)
-{
+void flipp_pomodoro_scene_timer_sync_view_state(void* ctx) {
     furi_assert(ctx);
 
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
     flipp_pomodoro_view_timer_set_state(
-        flipp_pomodoro_view_timer_get_view(app->timer_view),
-        app->state);
+        flipp_pomodoro_view_timer_get_view(app->timer_view), app->state);
 };
 
-void flipp_pomodoro_scene_timer_on_next_stage(void *ctx)
-{
+void flipp_pomodoro_scene_timer_on_next_stage(void* ctx) {
     furi_assert(ctx);
 
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
-    view_dispatcher_send_custom_event(
-        app->view_dispatcher,
-        FlippPomodoroAppCustomEventStageSkip);
+    view_dispatcher_send_custom_event(app->view_dispatcher, FlippPomodoroAppCustomEventStageSkip);
 };
 
-void flipp_pomodoro_scene_timer_on_ask_hint(void *ctx)
-{
-    FlippPomodoroApp *app = ctx;
+void flipp_pomodoro_scene_timer_on_ask_hint(void* ctx) {
+    FlippPomodoroApp* app = ctx;
     view_dispatcher_send_custom_event(
-        app->view_dispatcher,
-        FlippPomodoroAppCustomEventTimerAskHint);
+        app->view_dispatcher, FlippPomodoroAppCustomEventTimerAskHint);
 }
 
-void flipp_pomodoro_scene_timer_on_enter(void *ctx)
-{
+void flipp_pomodoro_scene_timer_on_enter(void* ctx) {
     furi_assert(ctx);
 
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
-    if (flipp_pomodoro__is_stage_expired(app->state))
-    {
+    if(flipp_pomodoro__is_stage_expired(app->state)) {
         flipp_pomodoro__destroy(app->state);
         app->state = flipp_pomodoro__new();
     }
@@ -104,18 +90,14 @@ void flipp_pomodoro_scene_timer_on_enter(void *ctx)
     flipp_pomodoro_view_timer_set_callback_context(app->timer_view, app);
 
     flipp_pomodoro_view_timer_set_on_ok_cb(
-        app->timer_view,
-        flipp_pomodoro_scene_timer_on_ask_hint);
+        app->timer_view, flipp_pomodoro_scene_timer_on_ask_hint);
 
     flipp_pomodoro_view_timer_set_on_right_cb(
-        app->timer_view,
-        flipp_pomodoro_scene_timer_on_next_stage);
+        app->timer_view, flipp_pomodoro_scene_timer_on_next_stage);
 };
 
-char *flipp_pomodoro_scene_timer_get_contextual_hint(FlippPomodoroApp *app)
-{
-    switch (flipp_pomodoro__get_stage(app->state))
-    {
+char* flipp_pomodoro_scene_timer_get_contextual_hint(FlippPomodoroApp* app) {
+    switch(flipp_pomodoro__get_stage(app->state)) {
     case FlippPomodoroStageFocus:
         return random_string_of_list(work_hints, sizeof(work_hints) / sizeof(work_hints[0]));
     case FlippPomodoroStageRest:
@@ -126,16 +108,14 @@ char *flipp_pomodoro_scene_timer_get_contextual_hint(FlippPomodoroApp *app)
     }
 }
 
-void flipp_pomodoro_scene_timer_handle_custom_event(FlippPomodoroApp *app, FlippPomodoroAppCustomEvent custom_event)
-{
-    switch (custom_event)
-    {
+void flipp_pomodoro_scene_timer_handle_custom_event(
+    FlippPomodoroApp* app,
+    FlippPomodoroAppCustomEvent custom_event) {
+    switch(custom_event) {
     case FlippPomodoroAppCustomEventTimerTick:
-        if (flipp_pomodoro__is_stage_expired(app->state))
-        {
+        if(flipp_pomodoro__is_stage_expired(app->state)) {
             view_dispatcher_send_custom_event(
-                app->view_dispatcher,
-                FlippPomodoroAppCustomEventStageComplete);
+                app->view_dispatcher, FlippPomodoroAppCustomEventStageComplete);
         }
         break;
     case FlippPomodoroAppCustomEventStateUpdated:
@@ -152,17 +132,13 @@ void flipp_pomodoro_scene_timer_handle_custom_event(FlippPomodoroApp *app, Flipp
     }
 };
 
-bool flipp_pomodoro_scene_timer_on_event(void *ctx, SceneManagerEvent event)
-{
+bool flipp_pomodoro_scene_timer_on_event(void* ctx, SceneManagerEvent event) {
     furi_assert(ctx);
-    FlippPomodoroApp *app = ctx;
+    FlippPomodoroApp* app = ctx;
 
-    switch (event.type)
-    {
+    switch(event.type) {
     case SceneManagerEventTypeCustom:
-        flipp_pomodoro_scene_timer_handle_custom_event(
-            app,
-            event.event);
+        flipp_pomodoro_scene_timer_handle_custom_event(app, event.event);
         return SceneEventConusmed;
     case SceneManagerEventTypeBack:
         scene_manager_next_scene(app->scene_manager, FlippPomodoroSceneInfo);
@@ -173,7 +149,6 @@ bool flipp_pomodoro_scene_timer_on_event(void *ctx, SceneManagerEvent event)
     return SceneEventNotConusmed;
 };
 
-void flipp_pomodoro_scene_timer_on_exit(void *ctx)
-{
+void flipp_pomodoro_scene_timer_on_exit(void* ctx) {
     UNUSED(ctx);
 };

views/flipp_pomodoro_info_view.c

@@ -7,31 +7,31 @@
 // Auto-compiled icons
 #include "flipp_pomodoro_icons.h"
 
-enum
-{
+enum {
     ViewInputConsumed = true,
     ViewInputNotConusmed = false,
 };
 
-struct FlippPomodoroInfoView
-{
-    View *view;
+struct FlippPomodoroInfoView {
+    View* view;
     FlippPomodoroInfoViewUserActionCb resume_timer_cb;
-    void *user_action_cb_ctx;
+    void* user_action_cb_ctx;
 };
 
-typedef struct
-{
+typedef struct {
     uint8_t pomodoros_completed;
     FlippPomodoroInfoViewMode mode;
 } FlippPomodoroInfoViewModel;
 
-static void flipp_pomodoro_info_view_draw_statistics(Canvas *canvas, FlippPomodoroInfoViewModel *model)
-{
-    FuriString *stats_string = furi_string_alloc();
+static void
+    flipp_pomodoro_info_view_draw_statistics(Canvas* canvas, FlippPomodoroInfoViewModel* model) {
+    FuriString* stats_string = furi_string_alloc();
 
-    furi_string_printf(stats_string, "So Long,\nand Thanks for All the Focus...\nand for completing\n\e#%i\e# pomodoro(s)", model->pomodoros_completed);
-    const char *stats_string_formatted = furi_string_get_cstr(stats_string);
+    furi_string_printf(
+        stats_string,
+        "So Long,\nand Thanks for All the Focus...\nand for completing\n\e#%i\e# pomodoro(s)",
+        model->pomodoros_completed);
+    const char* stats_string_formatted = furi_string_get_cstr(stats_string);
 
     elements_text_box(
         canvas,
@@ -49,73 +49,57 @@ static void flipp_pomodoro_info_view_draw_statistics(Canvas *canvas, FlippPomodo
     elements_button_left(canvas, "Guide");
 }
 
-static void flipp_pomodoro_info_view_draw_about(Canvas *canvas, FlippPomodoroInfoViewModel *model)
-{
+static void
+    flipp_pomodoro_info_view_draw_about(Canvas* canvas, FlippPomodoroInfoViewModel* model) {
     UNUSED(model);
     canvas_draw_icon(canvas, 0, 0, &I_flipp_pomodoro_learn_50x128);
     elements_button_left(canvas, "Stats");
 }
 
-static void flipp_pomodoro_info_view_draw_callback(Canvas *canvas, void *_model)
-{
-    if (!_model)
-    {
+static void flipp_pomodoro_info_view_draw_callback(Canvas* canvas, void* _model) {
+    if(!_model) {
         return;
     };
 
-    FlippPomodoroInfoViewModel *model = _model;
+    FlippPomodoroInfoViewModel* model = _model;
 
     canvas_clear(canvas);
 
-    if (model->mode == FlippPomodoroInfoViewModeStats)
-    {
+    if(model->mode == FlippPomodoroInfoViewModeStats) {
         flipp_pomodoro_info_view_draw_statistics(canvas, model);
-    }
-    else
-    {
+    } else {
         flipp_pomodoro_info_view_draw_about(canvas, model);
     }
 
     elements_button_right(canvas, "Resume");
 }
 
-void flipp_pomodoro_info_view_set_mode(View *view, FlippPomodoroInfoViewMode desired_mode)
-{
+void flipp_pomodoro_info_view_set_mode(View* view, FlippPomodoroInfoViewMode desired_mode) {
     with_view_model(
-        view,
-        FlippPomodoroInfoViewModel * model,
-        {
-            model->mode = desired_mode;
-        },
-        false);
+        view, FlippPomodoroInfoViewModel * model, { model->mode = desired_mode; }, false);
 }
 
-void flipp_pomodoro_info_view_toggle_mode(FlippPomodoroInfoView *info_view)
-{
+void flipp_pomodoro_info_view_toggle_mode(FlippPomodoroInfoView* info_view) {
     with_view_model(
         flipp_pomodoro_info_view_get_view(info_view),
         FlippPomodoroInfoViewModel * model,
         {
             flipp_pomodoro_info_view_set_mode(
                 flipp_pomodoro_info_view_get_view(info_view),
-                (model->mode == FlippPomodoroInfoViewModeStats) ? FlippPomodoroInfoViewModeAbout : FlippPomodoroInfoViewModeStats);
+                (model->mode == FlippPomodoroInfoViewModeStats) ? FlippPomodoroInfoViewModeAbout :
+                                                                  FlippPomodoroInfoViewModeStats);
         },
         true);
 }
 
-bool flipp_pomodoro_info_view_input_callback(InputEvent *event, void *ctx)
-{
-    FlippPomodoroInfoView *info_view = ctx;
+bool flipp_pomodoro_info_view_input_callback(InputEvent* event, void* ctx) {
+    FlippPomodoroInfoView* info_view = ctx;
 
-    if (event->type == InputTypePress)
-    {
-        if (event->key == InputKeyRight && info_view->resume_timer_cb != NULL)
-        {
+    if(event->type == InputTypePress) {
+        if(event->key == InputKeyRight && info_view->resume_timer_cb != NULL) {
             info_view->resume_timer_cb(info_view->user_action_cb_ctx);
             return ViewInputConsumed;
-        }
-        else if (event->key == InputKeyLeft)
-        {
+        } else if(event->key == InputKeyLeft) {
             flipp_pomodoro_info_view_toggle_mode(info_view);
             return ViewInputConsumed;
         }
@@ -124,44 +108,45 @@ bool flipp_pomodoro_info_view_input_callback(InputEvent *event, void *ctx)
     return ViewInputNotConusmed;
 }
 
-FlippPomodoroInfoView *flipp_pomodoro_info_view_alloc()
-{
-    FlippPomodoroInfoView *info_view = malloc(sizeof(FlippPomodoroInfoView));
+FlippPomodoroInfoView* flipp_pomodoro_info_view_alloc() {
+    FlippPomodoroInfoView* info_view = malloc(sizeof(FlippPomodoroInfoView));
     info_view->view = view_alloc();
 
-    view_allocate_model(flipp_pomodoro_info_view_get_view(info_view), ViewModelTypeLockFree, sizeof(FlippPomodoroInfoViewModel));
+    view_allocate_model(
+        flipp_pomodoro_info_view_get_view(info_view),
+        ViewModelTypeLockFree,
+        sizeof(FlippPomodoroInfoViewModel));
     view_set_context(flipp_pomodoro_info_view_get_view(info_view), info_view);
-    view_set_draw_callback(flipp_pomodoro_info_view_get_view(info_view), flipp_pomodoro_info_view_draw_callback);
-    view_set_input_callback(flipp_pomodoro_info_view_get_view(info_view), flipp_pomodoro_info_view_input_callback);
+    view_set_draw_callback(
+        flipp_pomodoro_info_view_get_view(info_view), flipp_pomodoro_info_view_draw_callback);
+    view_set_input_callback(
+        flipp_pomodoro_info_view_get_view(info_view), flipp_pomodoro_info_view_input_callback);
 
     return info_view;
 }
 
-View *flipp_pomodoro_info_view_get_view(FlippPomodoroInfoView *info_view)
-{
+View* flipp_pomodoro_info_view_get_view(FlippPomodoroInfoView* info_view) {
     return info_view->view;
 }
 
-void flipp_pomodoro_info_view_free(FlippPomodoroInfoView *info_view)
-{
+void flipp_pomodoro_info_view_free(FlippPomodoroInfoView* info_view) {
     furi_assert(info_view);
     view_free(info_view->view);
     free(info_view);
 }
 
-void flipp_pomodoro_info_view_set_pomodoros_completed(View *view, uint8_t pomodoros_completed)
-{
+void flipp_pomodoro_info_view_set_pomodoros_completed(View* view, uint8_t pomodoros_completed) {
     with_view_model(
         view,
         FlippPomodoroInfoViewModel * model,
-        {
-            model->pomodoros_completed = pomodoros_completed;
-        },
+        { model->pomodoros_completed = pomodoros_completed; },
         false);
 }
 
-void flipp_pomodoro_info_view_set_resume_timer_cb(FlippPomodoroInfoView *info_view, FlippPomodoroInfoViewUserActionCb user_action_cb, void *user_action_cb_ctx)
-{
+void flipp_pomodoro_info_view_set_resume_timer_cb(
+    FlippPomodoroInfoView* info_view,
+    FlippPomodoroInfoViewUserActionCb user_action_cb,
+    void* user_action_cb_ctx) {
     info_view->resume_timer_cb = user_action_cb;
     info_view->user_action_cb_ctx = user_action_cb_ctx;
 }

views/flipp_pomodoro_info_view.h

@@ -6,8 +6,7 @@
  *
  *  These are the modes that can be used in the FlippPomodoroInfoView
  */
-typedef enum
-{
+typedef enum {
     FlippPomodoroInfoViewModeStats,
     FlippPomodoroInfoViewModeAbout,
 } FlippPomodoroInfoViewMode;
@@ -19,14 +18,14 @@ typedef struct FlippPomodoroInfoView FlippPomodoroInfoView;
  *
  *  Callback functions of this type are called when a user action is performed.
  */
-typedef void (*FlippPomodoroInfoViewUserActionCb)(void *ctx);
+typedef void (*FlippPomodoroInfoViewUserActionCb)(void* ctx);
 
 /** @brief Allocate a new FlippPomodoroInfoView
  *
  *  Allocates a new FlippPomodoroInfoView and returns a pointer to it.
  *  @return A pointer to a new FlippPomodoroInfoView
  */
-FlippPomodoroInfoView *flipp_pomodoro_info_view_alloc();
+FlippPomodoroInfoView* flipp_pomodoro_info_view_alloc();
 
 /** @brief Get the view from a FlippPomodoroInfoView
  *
@@ -34,14 +33,14 @@ FlippPomodoroInfoView *flipp_pomodoro_info_view_alloc();
  *  @param info_view A pointer to a FlippPomodoroInfoView
  *  @return A pointer to the view of the FlippPomodoroInfoView
  */
-View *flipp_pomodoro_info_view_get_view(FlippPomodoroInfoView *info_view);
+View* flipp_pomodoro_info_view_get_view(FlippPomodoroInfoView* info_view);
 
 /** @brief Free a FlippPomodoroInfoView
  *
  *  Frees the memory used by a FlippPomodoroInfoView.
  *  @param info_view A pointer to a FlippPomodoroInfoView
  */
-void flipp_pomodoro_info_view_free(FlippPomodoroInfoView *info_view);
+void flipp_pomodoro_info_view_free(FlippPomodoroInfoView* info_view);
 
 /** @brief Set the number of completed pomodoros in the view
  *
@@ -49,7 +48,7 @@ void flipp_pomodoro_info_view_free(FlippPomodoroInfoView *info_view);
  *  @param info_view A pointer to the view
  *  @param pomodoros_completed The number of completed pomodoros
  */
-void flipp_pomodoro_info_view_set_pomodoros_completed(View *info_view, uint8_t pomodoros_completed);
+void flipp_pomodoro_info_view_set_pomodoros_completed(View* info_view, uint8_t pomodoros_completed);
 
 /** @brief Set the callback function to be called when the timer should be resumed
  *
@@ -58,7 +57,10 @@ void flipp_pomodoro_info_view_set_pomodoros_completed(View *info_view, uint8_t p
  *  @param user_action_cb The callback function
  *  @param user_action_cb_ctx The context to be passed to the callback function
  */
-void flipp_pomodoro_info_view_set_resume_timer_cb(FlippPomodoroInfoView *info_view, FlippPomodoroInfoViewUserActionCb user_action_cb, void *user_action_cb_ctx);
+void flipp_pomodoro_info_view_set_resume_timer_cb(
+    FlippPomodoroInfoView* info_view,
+    FlippPomodoroInfoViewUserActionCb user_action_cb,
+    void* user_action_cb_ctx);
 
 /** @brief Set the mode of the view
  *
@@ -66,4 +68,4 @@ void flipp_pomodoro_info_view_set_resume_timer_cb(FlippPomodoroInfoView *info_vi
  *  @param view A pointer to the view
  *  @param desired_mode The desired mode
  */
-void flipp_pomodoro_info_view_set_mode(View *view, FlippPomodoroInfoViewMode desired_mode);
+void flipp_pomodoro_info_view_set_mode(View* view, FlippPomodoroInfoViewMode desired_mode);

views/flipp_pomodoro_timer_view.c

@@ -10,53 +10,48 @@
 // Auto-compiled icons
 #include "flipp_pomodoro_icons.h"
 
-enum
-{
+enum {
     ViewInputConsumed = true,
     ViewInputNotConusmed = false,
 };
 
-struct FlippPomodoroTimerView
-{
-    View *view;
+struct FlippPomodoroTimerView {
+    View* view;
     FlippPomodoroTimerViewInputCb right_cb;
     FlippPomodoroTimerViewInputCb ok_cb;
-    void *callback_context;
+    void* callback_context;
 };
 
-typedef struct
-{
-    IconAnimation *icon;
-    FlippPomodoroState *state;
+typedef struct {
+    IconAnimation* icon;
+    FlippPomodoroState* state;
     size_t scroll_counter;
-    char *current_hint;
+    char* current_hint;
 } FlippPomodoroTimerViewModel;
 
-static const Icon *stage_background_image[] = {
+static const Icon* stage_background_image[] = {
     [FlippPomodoroStageFocus] = &A_flipp_pomodoro_focus_64,
     [FlippPomodoroStageRest] = &A_flipp_pomodoro_rest_64,
     [FlippPomodoroStageLongBreak] = &A_flipp_pomodoro_rest_64,
 };
 
-static void flipp_pomodoro_view_timer_draw_countdown(Canvas *canvas, TimeDifference remaining_time)
-{
+static void
+    flipp_pomodoro_view_timer_draw_countdown(Canvas* canvas, TimeDifference remaining_time) {
     canvas_set_font(canvas, FontBigNumbers);
     const uint8_t right_border_margin = 1;
 
     const uint8_t countdown_box_height = canvas_height(canvas) * 0.4;
     const uint8_t countdown_box_width = canvas_width(canvas) * 0.5;
-    const uint8_t countdown_box_x = canvas_width(canvas) - countdown_box_width - right_border_margin;
+    const uint8_t countdown_box_x =
+        canvas_width(canvas) - countdown_box_width - right_border_margin;
     const uint8_t countdown_box_y = 15;
 
-    elements_bold_rounded_frame(canvas,
-                                countdown_box_x,
-                                countdown_box_y,
-                                countdown_box_width,
-                                countdown_box_height);
+    elements_bold_rounded_frame(
+        canvas, countdown_box_x, countdown_box_y, countdown_box_width, countdown_box_height);
 
-    FuriString *timer_string = furi_string_alloc();
+    FuriString* timer_string = furi_string_alloc();
     furi_string_printf(timer_string, "%02u:%02u", remaining_time.minutes, remaining_time.seconds);
-    const char *remaining_stage_time_string = furi_string_get_cstr(timer_string);
+    const char* remaining_stage_time_string = furi_string_get_cstr(timer_string);
     canvas_draw_str_aligned(
         canvas,
         countdown_box_x + (countdown_box_width / 2),
@@ -69,38 +64,24 @@ static void flipp_pomodoro_view_timer_draw_countdown(Canvas *canvas, TimeDiffere
 };
 
 static void draw_str_with_drop_shadow(
-    Canvas *canvas, uint8_t x,
+    Canvas* canvas,
+    uint8_t x,
     uint8_t y,
     Align horizontal,
     Align vertical,
-    const char *str)
-{
+    const char* str) {
     canvas_set_color(canvas, ColorWhite);
-    for (int x_off = -2; x_off <= 2; x_off++)
-    {
-        for (int y_off = -2; y_off <= 2; y_off++)
-        {
-            canvas_draw_str_aligned(
-                canvas,
-                x + x_off,
-                y + y_off,
-                horizontal,
-                vertical,
-                str);
+    for(int x_off = -2; x_off <= 2; x_off++) {
+        for(int y_off = -2; y_off <= 2; y_off++) {
+            canvas_draw_str_aligned(canvas, x + x_off, y + y_off, horizontal, vertical, str);
         }
     }
     canvas_set_color(canvas, ColorBlack);
-    canvas_draw_str_aligned(
-        canvas,
-        x,
-        y,
-        horizontal,
-        vertical,
-        str);
+    canvas_draw_str_aligned(canvas, x, y, horizontal, vertical, str);
 }
 
-static void flipp_pomodoro_view_timer_draw_current_stage_label(Canvas *canvas, FlippPomodoroState *state)
-{
+static void
+    flipp_pomodoro_view_timer_draw_current_stage_label(Canvas* canvas, FlippPomodoroState* state) {
     canvas_set_font(canvas, FontPrimary);
     draw_str_with_drop_shadow(
         canvas,
@@ -111,13 +92,12 @@ static void flipp_pomodoro_view_timer_draw_current_stage_label(Canvas *canvas, F
         flipp_pomodoro__current_stage_label(state));
 }
 
-static void flipp_pomodoro_view_timer_draw_hint(Canvas *canvas, FlippPomodoroTimerViewModel *model)
-{
+static void
+    flipp_pomodoro_view_timer_draw_hint(Canvas* canvas, FlippPomodoroTimerViewModel* model) {
     size_t MAX_SCROLL_COUNTER = 300;
     uint8_t SCROLL_DELAY_FRAMES = 3;
 
-    if (model->scroll_counter >= MAX_SCROLL_COUNTER || model->current_hint == NULL)
-    {
+    if(model->scroll_counter >= MAX_SCROLL_COUNTER || model->current_hint == NULL) {
         return;
     }
 
@@ -127,23 +107,21 @@ static void flipp_pomodoro_view_timer_draw_hint(Canvas *canvas, FlippPomodoroTim
     uint8_t hint_x = canvas_width(canvas) - hint_width - 6;
     uint8_t hint_y = 35;
 
-    FuriString *displayed_hint_string = furi_string_alloc();
+    FuriString* displayed_hint_string = furi_string_alloc();
 
-    furi_string_printf(
-        displayed_hint_string,
-        "%s",
-        model->current_hint);
+    furi_string_printf(displayed_hint_string, "%s", model->current_hint);
 
     size_t perfect_duration = furi_string_size(displayed_hint_string) * 1.5;
 
-    if (model->scroll_counter > perfect_duration)
-    {
+    if(model->scroll_counter > perfect_duration) {
         model->scroll_counter = MAX_SCROLL_COUNTER;
         furi_string_free(displayed_hint_string);
         return;
     }
 
-    size_t scroll_offset = (model->scroll_counter < SCROLL_DELAY_FRAMES) ? 0 : model->scroll_counter - SCROLL_DELAY_FRAMES;
+    size_t scroll_offset = (model->scroll_counter < SCROLL_DELAY_FRAMES) ?
+                               0 :
+                               model->scroll_counter - SCROLL_DELAY_FRAMES;
 
     canvas_set_color(canvas, ColorWhite);
     canvas_draw_box(canvas, hint_x, hint_y, hint_width + 3, hint_height);
@@ -163,24 +141,20 @@ static void flipp_pomodoro_view_timer_draw_hint(Canvas *canvas, FlippPomodoroTim
     model->scroll_counter++;
 }
 
-static void flipp_pomodoro_view_timer_draw_callback(Canvas *canvas, void *_model)
-{
-    if (!_model)
-    {
+static void flipp_pomodoro_view_timer_draw_callback(Canvas* canvas, void* _model) {
+    if(!_model) {
         return;
     };
 
-    FlippPomodoroTimerViewModel *model = _model;
+    FlippPomodoroTimerViewModel* model = _model;
 
     canvas_clear(canvas);
-    if (model->icon)
-    {
+    if(model->icon) {
         canvas_draw_icon_animation(canvas, 0, 0, model->icon);
     }
 
     flipp_pomodoro_view_timer_draw_countdown(
-        canvas,
-        flipp_pomodoro__stage_remaining_duration(model->state));
+        canvas, flipp_pomodoro__stage_remaining_duration(model->state));
 
     flipp_pomodoro_view_timer_draw_current_stage_label(canvas, model->state);
 
@@ -191,21 +165,18 @@ static void flipp_pomodoro_view_timer_draw_callback(Canvas *canvas, void *_model
     flipp_pomodoro_view_timer_draw_hint(canvas, model);
 };
 
-bool flipp_pomodoro_view_timer_input_callback(InputEvent *event, void *ctx)
-{
+bool flipp_pomodoro_view_timer_input_callback(InputEvent* event, void* ctx) {
     furi_assert(ctx);
     furi_assert(event);
-    FlippPomodoroTimerView *timer = ctx;
+    FlippPomodoroTimerView* timer = ctx;
 
     const bool is_press_event = event->type == InputTypePress;
 
-    if (!is_press_event)
-    {
+    if(!is_press_event) {
         return ViewInputNotConusmed;
     }
 
-    switch (event->key)
-    {
+    switch(event->key) {
     case InputKeyRight:
         timer->right_cb(timer->callback_context);
         return ViewInputConsumed;
@@ -217,14 +188,12 @@ bool flipp_pomodoro_view_timer_input_callback(InputEvent *event, void *ctx)
     }
 };
 
-View *flipp_pomodoro_view_timer_get_view(FlippPomodoroTimerView *timer)
-{
+View* flipp_pomodoro_view_timer_get_view(FlippPomodoroTimerView* timer) {
     furi_assert(timer);
     return timer->view;
 };
 
-void flipp_pomodoro_view_timer_display_hint(View *view, char *hint)
-{
+void flipp_pomodoro_view_timer_display_hint(View* view, char* hint) {
     with_view_model(
         view,
         FlippPomodoroTimerViewModel * model,
@@ -235,14 +204,12 @@ void flipp_pomodoro_view_timer_display_hint(View *view, char *hint)
         true);
 }
 
-void flipp_pomodoro_view_timer_assign_animation(View *view)
-{
+void flipp_pomodoro_view_timer_assign_animation(View* view) {
     with_view_model(
         view,
         FlippPomodoroTimerViewModel * model,
         {
-            if (model->icon)
-            {
+            if(model->icon) {
                 icon_animation_free(model->icon);
             }
             model->icon = icon_animation_alloc(
@@ -253,12 +220,14 @@ void flipp_pomodoro_view_timer_assign_animation(View *view)
         true);
 }
 
-FlippPomodoroTimerView *flipp_pomodoro_view_timer_alloc()
-{
-    FlippPomodoroTimerView *timer = malloc(sizeof(FlippPomodoroTimerView));
+FlippPomodoroTimerView* flipp_pomodoro_view_timer_alloc() {
+    FlippPomodoroTimerView* timer = malloc(sizeof(FlippPomodoroTimerView));
     timer->view = view_alloc();
 
-    view_allocate_model(flipp_pomodoro_view_timer_get_view(timer), ViewModelTypeLockFree, sizeof(FlippPomodoroTimerViewModel));
+    view_allocate_model(
+        flipp_pomodoro_view_timer_get_view(timer),
+        ViewModelTypeLockFree,
+        sizeof(FlippPomodoroTimerViewModel));
 
     view_set_context(flipp_pomodoro_view_timer_get_view(timer), timer);
     view_set_draw_callback(timer->view, flipp_pomodoro_view_timer_draw_callback);
@@ -267,37 +236,37 @@ FlippPomodoroTimerView *flipp_pomodoro_view_timer_alloc()
     with_view_model(
         flipp_pomodoro_view_timer_get_view(timer),
         FlippPomodoroTimerViewModel * model,
-        {
-            model->scroll_counter = 0;
-        },
+        { model->scroll_counter = 0; },
         false);
 
     return timer;
 };
 
-void flipp_pomodoro_view_timer_set_callback_context(FlippPomodoroTimerView *timer, void *callback_ctx)
-{
+void flipp_pomodoro_view_timer_set_callback_context(
+    FlippPomodoroTimerView* timer,
+    void* callback_ctx) {
     furi_assert(timer);
     furi_assert(callback_ctx);
     timer->callback_context = callback_ctx;
 }
 
-void flipp_pomodoro_view_timer_set_on_right_cb(FlippPomodoroTimerView *timer, FlippPomodoroTimerViewInputCb right_cb)
-{
+void flipp_pomodoro_view_timer_set_on_right_cb(
+    FlippPomodoroTimerView* timer,
+    FlippPomodoroTimerViewInputCb right_cb) {
     furi_assert(timer);
     furi_assert(right_cb);
     timer->right_cb = right_cb;
 };
 
-void flipp_pomodoro_view_timer_set_on_ok_cb(FlippPomodoroTimerView *timer, FlippPomodoroTimerViewInputCb ok_kb)
-{
+void flipp_pomodoro_view_timer_set_on_ok_cb(
+    FlippPomodoroTimerView* timer,
+    FlippPomodoroTimerViewInputCb ok_kb) {
     furi_assert(ok_kb);
     furi_assert(timer);
     timer->ok_cb = ok_kb;
 }
 
-void flipp_pomodoro_view_timer_set_state(View *view, FlippPomodoroState *state)
-{
+void flipp_pomodoro_view_timer_set_state(View* view, FlippPomodoroState* state) {
     furi_assert(view);
     furi_assert(state);
     with_view_model(
@@ -311,15 +280,12 @@ void flipp_pomodoro_view_timer_set_state(View *view, FlippPomodoroState *state)
     flipp_pomodoro_view_timer_assign_animation(view);
 };
 
-void flipp_pomodoro_view_timer_free(FlippPomodoroTimerView *timer)
-{
+void flipp_pomodoro_view_timer_free(FlippPomodoroTimerView* timer) {
     furi_assert(timer);
     with_view_model(
         timer->view,
         FlippPomodoroTimerViewModel * model,
-        {
-            icon_animation_free(model->icon);
-        },
+        { icon_animation_free(model->icon); },
         false);
     view_free(timer->view);
 

views/flipp_pomodoro_timer_view.h

@@ -5,20 +5,26 @@
 
 typedef struct FlippPomodoroTimerView FlippPomodoroTimerView;
 
-typedef void (*FlippPomodoroTimerViewInputCb)(void *ctx);
+typedef void (*FlippPomodoroTimerViewInputCb)(void* ctx);
 
-FlippPomodoroTimerView *flipp_pomodoro_view_timer_alloc();
+FlippPomodoroTimerView* flipp_pomodoro_view_timer_alloc();
 
-View *flipp_pomodoro_view_timer_get_view(FlippPomodoroTimerView *timer);
+View* flipp_pomodoro_view_timer_get_view(FlippPomodoroTimerView* timer);
 
-void flipp_pomodoro_view_timer_free(FlippPomodoroTimerView *timer);
+void flipp_pomodoro_view_timer_free(FlippPomodoroTimerView* timer);
 
-void flipp_pomodoro_view_timer_set_state(View *view, FlippPomodoroState *state);
+void flipp_pomodoro_view_timer_set_state(View* view, FlippPomodoroState* state);
 
-void flipp_pomodoro_view_timer_set_callback_context(FlippPomodoroTimerView *timer, void *callback_ctx);
+void flipp_pomodoro_view_timer_set_callback_context(
+    FlippPomodoroTimerView* timer,
+    void* callback_ctx);
 
-void flipp_pomodoro_view_timer_set_on_right_cb(FlippPomodoroTimerView *timer, FlippPomodoroTimerViewInputCb right_cb);
+void flipp_pomodoro_view_timer_set_on_right_cb(
+    FlippPomodoroTimerView* timer,
+    FlippPomodoroTimerViewInputCb right_cb);
 
-void flipp_pomodoro_view_timer_set_on_ok_cb(FlippPomodoroTimerView *timer, FlippPomodoroTimerViewInputCb ok_cb);
+void flipp_pomodoro_view_timer_set_on_ok_cb(
+    FlippPomodoroTimerView* timer,
+    FlippPomodoroTimerViewInputCb ok_cb);
 
-void flipp_pomodoro_view_timer_display_hint(View *view, char *hint);
+void flipp_pomodoro_view_timer_display_hint(View* view, char* hint);