Merge branch 'pr/256' into Clock

Author: RogueMaster

applications/clock_app/clock_app.c

@@ -6,9 +6,6 @@
 
 #define TAG "Clock"
 
-bool timerStarted = false;
-int timerSecs = 0;
-
 typedef enum {
     EventTypeTick,
     EventTypeKey,
@@ -20,7 +17,11 @@ typedef struct {
 } PluginEvent;
 
 typedef struct {
-    FuriHalRtcDateTime datetime;
+    FuriMutex* mutex;
+    FuriMessageQueue* event_queue;
+    uint32_t timer_start_timestamp;
+    uint32_t timer_stopped_seconds;
+    bool timer_running;
     bool militaryTime; // 24 hour
 } ClockState;
 
@@ -31,61 +32,60 @@ static void clock_input_callback(InputEvent* input_event, FuriMessageQueue* even
 }
 
 static void clock_render_callback(Canvas* const canvas, void* ctx) {
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-    ClockState* state = (ClockState*)acquire_mutex((ValueMutex*)ctx, 25);
-    if(state == NULL) {
-        FURI_LOG_E(TAG, "state was NULL\r\n");
+    ClockState* state = ctx;
+    if(furi_mutex_acquire(state->mutex, 200) != FuriStatusOk) {
+        // Can't obtain mutex, requeue render
+        PluginEvent event = {.type = EventTypeTick};
+        furi_message_queue_put(state->event_queue, &event, 0);
         return;
     }
+
+    FuriHalRtcDateTime curr_dt;
+    furi_hal_rtc_get_datetime(&curr_dt);
+    uint32_t curr_ts = furi_hal_rtc_datetime_to_timestamp(&curr_dt);
+
     char strings[3][20];
-    int curMin = (timerSecs / 60);
-    int curSec = timerSecs - (curMin * 60);
-    snprintf(
-        strings[0],
-        20,
-        "%.4d-%.2d-%.2d",
-        state->datetime.year,
-        state->datetime.month,
-        state->datetime.day);
-
-    uint8_t hour = state->datetime.hour;
+    snprintf(strings[0], 20, "%.4d-%.2d-%.2d", curr_dt.year, curr_dt.month, curr_dt.day);
+
+    uint8_t hour = curr_dt.hour;
     // bool pm = false;
-    if (!state->militaryTime && hour > 12) {
+    if(!state->militaryTime && hour > 12) {
         hour -= 12;
         // pm = true;
     }
-    snprintf(
-        strings[1],
-        20,
-        "%.2d:%.2d:%.2d",
-        hour,
-        state->datetime.minute,
-        state->datetime.second);
-    snprintf(strings[2], 20, "%.2d:%.2d", curMin, curSec);
-    release_mutex((ValueMutex*)ctx, state);
+    snprintf(strings[1], 20, "%.2d:%.2d:%.2d", hour, curr_dt.minute, curr_dt.second);
+
+    bool timer_running = state->timer_running;
+    uint32_t timer_start_timestamp = state->timer_start_timestamp;
+    uint32_t timer_stopped_seconds = state->timer_stopped_seconds;
+
+    furi_mutex_release(state->mutex);
+
     canvas_set_font(canvas, FontBigNumbers);
-    if(timerStarted || timerSecs!=0) {
+    if(timer_start_timestamp != 0) {
+        int32_t elapsed_secs = timer_running ? (curr_ts - timer_start_timestamp) :
+                                               timer_stopped_seconds;
+        snprintf(strings[2], 20, "%.2ld:%.2ld", elapsed_secs / 60, elapsed_secs % 60);
         canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, strings[1]); // DRAW TIME
         canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignTop, strings[2]); // DRAW TIMER
         canvas_set_font(canvas, FontSecondary);
         canvas_draw_str_aligned(canvas, 64, 20, AlignCenter, AlignTop, strings[0]); // DRAW DATE
+        elements_button_left(canvas, "Reset");
     } else {
         canvas_draw_str_aligned(canvas, 64, 26, AlignCenter, AlignCenter, strings[1]); // DRAW TIME
         canvas_set_font(canvas, FontSecondary);
         canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignTop, strings[0]); // DRAW DATE
         elements_button_left(canvas, state->militaryTime ? "12h" : "24h");
     }
-    if(timerStarted) {
+    if(timer_running) {
         elements_button_center(canvas, "Stop");
     } else {
         elements_button_center(canvas, "Start");
     }
-    if(timerSecs!=0) elements_button_left(canvas, "Reset");
 }
 
 static void clock_state_init(ClockState* const state) {
-    furi_hal_rtc_get_datetime(&state->datetime);
+    memset(state, 0, sizeof(ClockState));
     state->militaryTime = true;
 }
 
@@ -94,82 +94,113 @@ static void clock_tick(void* ctx) {
     furi_assert(ctx);
     FuriMessageQueue* event_queue = ctx;
     PluginEvent event = {.type = EventTypeTick};
-    if(timerStarted) {
-        timerSecs = timerSecs + 1;
-    }
-    // It's OK to loose this event if system overloaded
+    // It's OK to lose this event if system overloaded
     furi_message_queue_put(event_queue, &event, 0);
 }
 
 int32_t clock_app(void* p) {
     UNUSED(p);
-    timerStarted = false;
-    timerSecs = 0;
-    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
     ClockState* plugin_state = malloc(sizeof(ClockState));
     clock_state_init(plugin_state);
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(ClockState))) {
-        FURI_LOG_E(TAG, "cannot create mutex\r\n");
-        furi_message_queue_free(event_queue);
+    plugin_state->event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
+    if(plugin_state->event_queue == NULL) {
+        FURI_LOG_E(TAG, "cannot create event queue\n");
+        free(plugin_state);
+        return 255;
+    }
+
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(plugin_state->mutex == NULL) {
+        FURI_LOG_E(TAG, "cannot create mutex\n");
+        furi_message_queue_free(plugin_state->event_queue);
+        free(plugin_state);
+        return 255;
+    }
+
+    FuriTimer* timer =
+        furi_timer_alloc(clock_tick, FuriTimerTypePeriodic, plugin_state->event_queue);
+    if(timer == NULL) {
+        FURI_LOG_E(TAG, "cannot create timer\n");
+        furi_mutex_free(plugin_state->mutex);
+        furi_message_queue_free(plugin_state->event_queue);
         free(plugin_state);
         return 255;
     }
+
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, clock_render_callback, &state_mutex);
-    view_port_input_callback_set(view_port, clock_input_callback, event_queue);
-    FuriTimer* timer = furi_timer_alloc(clock_tick, FuriTimerTypePeriodic, event_queue);
-    furi_timer_start(timer, furi_kernel_get_tick_frequency());
+    view_port_draw_callback_set(view_port, clock_render_callback, plugin_state);
+    view_port_input_callback_set(view_port, clock_input_callback, plugin_state->event_queue);
+
     // Open GUI and register view_port
     Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+    furi_timer_start(timer, furi_kernel_get_tick_frequency());
+
     // Main loop
     PluginEvent event;
     for(bool processing = true; processing;) {
-        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        ClockState* plugin_state = (ClockState*)acquire_mutex_block(&state_mutex);
+        FuriStatus event_status = furi_message_queue_get(plugin_state->event_queue, &event, 100);
         if(event_status == FuriStatusOk) {
+            if(furi_mutex_acquire(plugin_state->mutex, FuriWaitForever) != FuriStatusOk) continue;
             // press events
             if(event.type == EventTypeKey) {
                 if(event.input.type == InputTypeShort || event.input.type == InputTypeRepeat) {
-					if (event.input.key == InputKeyOk) {
-						// START/STOP TIMER
-                        if(timerStarted) {
-                            timerStarted = false;
+                    if(event.input.key == InputKeyOk) {
+                        // START/STOP TIMER
+                        FuriHalRtcDateTime curr_dt;
+                        furi_hal_rtc_get_datetime(&curr_dt);
+                        uint32_t curr_ts = furi_hal_rtc_datetime_to_timestamp(&curr_dt);
+
+                        if(plugin_state->timer_running) {
+                            // Update stopped seconds
+                            plugin_state->timer_stopped_seconds =
+                                curr_ts - plugin_state->timer_start_timestamp;
                         } else {
-                            timerStarted = true;
+                            if(plugin_state->timer_start_timestamp == 0) {
+                                // Set starting timestamp if this is first time
+                                plugin_state->timer_start_timestamp = curr_ts;
+                            } else {
+                                // Timer was already running, need to slightly readjust so we don't
+                                // count the intervening time
+                                plugin_state->timer_start_timestamp =
+                                    curr_ts - plugin_state->timer_stopped_seconds;
+                            }
                         }
-					} else if (event.input.key == InputKeyLeft) {
-                        if (timerStarted || timerSecs!=0) {
-                            timerSecs = 0;
+                        plugin_state->timer_running = !plugin_state->timer_running;
+                    } else if(event.input.key == InputKeyLeft) {
+                        if(plugin_state->timer_start_timestamp != 0) {
+                            // Reset seconds
+                            plugin_state->timer_running = false;
+                            plugin_state->timer_start_timestamp = 0;
+                            plugin_state->timer_stopped_seconds = 0;
                         } else {
+                            // Toggle 12/24 hours
                             plugin_state->militaryTime = !plugin_state->militaryTime;
                         }
-					} else if (event.input.key == InputKeyBack) {
+                    } else if(event.input.key == InputKeyBack) {
                         // Exit the plugin
                         processing = false;
-					} else {
-						// KEY NOT PROGRAMMED
-					}
+                    }
                 }
             } else if(event.type == EventTypeTick) {
-                furi_hal_rtc_get_datetime(&plugin_state->datetime);
+                // Do nothing, just need to update viewport
             }
+            view_port_update(view_port);
+            furi_mutex_release(plugin_state->mutex);
         } else {
-            FURI_LOG_D(TAG, "osMessageQueue: event timeout");
             // event timeout
+            // FURI_LOG_D(TAG, "osMessageQueue: event timeout");
         }
-        view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
     }
+    // Cleanup
     furi_timer_free(timer);
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_message_queue_free(plugin_state->event_queue);
+    furi_mutex_free(plugin_state->mutex);
     free(plugin_state);
-    furi_message_queue_free(event_queue);
     return 0;
 }