minor fixes:

* more consistent function names
* lapCapacity as constexpr
* LastLap returns std::optional
* simplified handling of TickType_t values
* removed unused methods
* minor fix in lap rendering

Author: codingjourney

src/components/stopwatch/StopWatchController.cpp

@@ -2,20 +2,6 @@
 
 using namespace Pinetime::Controllers;
 
-namespace {
-  TickType_t CalculateDelta(const TickType_t startTime, const TickType_t currentTime) {
-    TickType_t delta = 0;
-    // Take care of overflow
-    if (startTime > currentTime) {
-      delta = 0xffffffff - startTime;
-      delta += (currentTime + 1);
-    } else {
-      delta = currentTime - startTime;
-    }
-    return delta;
-  }
-}
-
 StopWatchController::StopWatchController() {
   Clear();
 }
@@ -29,14 +15,14 @@ void StopWatchController::Start() {
 
 void StopWatchController::Pause() {
   currentState = StopWatchStates::Paused;
-  timeElapsedPreviously += CalculateDelta(startTime, xTaskGetTickCount());
+  timeElapsedPreviously += xTaskGetTickCount() - startTime;
 }
 
 void StopWatchController::Clear() {
   currentState = StopWatchStates::Cleared;
   timeElapsedPreviously = 0;
 
-  for (int i = 0; i < LAP_CAPACITY; i++) {
+  for (int i = 0; i < lapCapacity; i++) {
     laps[i].count = 0;
     laps[i].time = 0;
   }
@@ -51,32 +37,25 @@ void StopWatchController::PushLap() {
   laps[lapHead].time = lapEnd;
   laps[lapHead].count = lapCount + 1;
   lapCount += 1;
-  lapHead = lapCount % LAP_CAPACITY;
-}
-
-int StopWatchController::GetLapNum() {
-  if (lapCount < LAP_CAPACITY)
-    return lapCount;
-  else
-    return LAP_CAPACITY;
+  lapHead = lapCount % lapCapacity;
 }
 
 int StopWatchController::GetLapCount() {
   return lapCount;
 }
 
 int Wrap(int index) {
-  return ((index % LAP_CAPACITY) + LAP_CAPACITY) % LAP_CAPACITY;
+  return ((index % lapCapacity) + lapCapacity) % lapCapacity;
 }
 
-LapInfo* StopWatchController::LastLap(int lap) {
-  if (lap >= LAP_CAPACITY || lap > lapCount || lapCount == 0) {
-    // Return "empty" LapInfo_t
-    return &emptyLapInfo;
+std::optional<LapInfo> StopWatchController::LastLap(int lap) {
+  if (lap >= lapCapacity || lap >= lapCount) {
+    return {};
   }
   // Index backwards
-  int index = Wrap(lapHead - lap);
-  return &laps[index];
+  int mostRecentLap = lapHead - 1;
+  int index = Wrap(mostRecentLap - lap);
+  return laps[index];
 }
 
 // Data / State acess
@@ -85,7 +64,7 @@ TickType_t StopWatchController::GetElapsedTime() {
   if (!IsRunning()) {
     return timeElapsedPreviously;
   }
-  return timeElapsedPreviously + CalculateDelta(startTime, xTaskGetTickCount());
+  return timeElapsedPreviously + (xTaskGetTickCount() - startTime);
 }
 
 bool StopWatchController::IsRunning() {

src/components/stopwatch/StopWatchController.h

@@ -1,10 +1,9 @@
 #pragma once
 
 #include <FreeRTOS.h>
+#include <optional>
 #include <timers.h>
 
-#define LAP_CAPACITY 2
-
 namespace Pinetime {
   namespace System {
     class SystemTask;
@@ -18,6 +17,8 @@ namespace Pinetime {
       TickType_t time = 0; // Delta time from beginning of stopwatch
     };
 
+    constexpr int lapCapacity = 2;
+
     class StopWatchController {
     public:
       StopWatchController();
@@ -34,32 +35,28 @@ namespace Pinetime {
       /// Only the latest laps are stored, the lap count is saved until reset
       void PushLap();
 
-      /// Returns actual count of stored laps
-      int GetLapNum();
-
       /// Returns lapCount
       int GetLapCount();
 
       /// Indexes into lap history, with 0 being the latest lap.
-      /// If the lap is unavailable, count and time will be 0. If there is a
-      /// real value, count should be above 0
-      LapInfo* LastLap(int lap = 0);
+      std::optional<LapInfo> LastLap(int lap = 0);
 
       bool IsRunning();
       bool IsCleared();
       bool IsPaused();
 
-    private:
+    // private:
       // Current state of stopwatch
       StopWatchStates currentState = StopWatchStates::Cleared;
       // Start time of current duration
       TickType_t startTime = 0;
       // How much time was elapsed before current duration
       TickType_t timeElapsedPreviously = 0;
       // Stores lap times
-      LapInfo laps[LAP_CAPACITY];
-      LapInfo emptyLapInfo = {.count = 0, .time = 0};
+      LapInfo laps[lapCapacity];
+      // Total lap count; may exceed lapCapacity
       int lapCount = 0;
+      // Index for next lap time; must be lower than lapCapacity
       int lapHead = 0;
     };
   }

src/displayapp/screens/StopWatch.cpp

@@ -7,7 +7,7 @@ using namespace Pinetime::Applications::Screens;
 using namespace Pinetime::Controllers;
 
 namespace {
-  TimeSeparated convertTicksToTimeSegments(const TickType_t timeElapsed) {
+  TimeSeparated ConvertTicksToTimeSegments(const TickType_t timeElapsed) {
     // Centiseconds
     const int timeElapsedCentis = timeElapsed * 100 / configTICK_RATE_HZ;
 
@@ -18,14 +18,14 @@ namespace {
     return TimeSeparated {hours, mins, secs, hundredths};
   }
 
-  void play_pause_event_handler(lv_obj_t* obj, lv_event_t event) {
+  void PlayPauseEventHandler(lv_obj_t* obj, lv_event_t event) {
     auto* stopWatch = static_cast<StopWatch*>(obj->user_data);
     if (event == LV_EVENT_CLICKED) {
       stopWatch->PlayPauseBtnEventHandler();
     }
   }
 
-  void stop_lap_event_handler(lv_obj_t* obj, lv_event_t event) {
+  void StopLapEventHandler(lv_obj_t* obj, lv_event_t event) {
     auto* stopWatch = static_cast<StopWatch*>(obj->user_data);
     if (event == LV_EVENT_CLICKED) {
       stopWatch->StopLapBtnEventHandler();
@@ -42,14 +42,14 @@ StopWatch::StopWatch(System::SystemTask& systemTask,
   static constexpr uint8_t btnHeight = 80;
   btnPlayPause = lv_btn_create(lv_scr_act(), nullptr);
   btnPlayPause->user_data = this;
-  lv_obj_set_event_cb(btnPlayPause, play_pause_event_handler);
+  lv_obj_set_event_cb(btnPlayPause, PlayPauseEventHandler);
   lv_obj_set_size(btnPlayPause, btnWidth, btnHeight);
   lv_obj_align(btnPlayPause, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
   txtPlayPause = lv_label_create(btnPlayPause, nullptr);
 
   btnStopLap = lv_btn_create(lv_scr_act(), nullptr);
   btnStopLap->user_data = this;
-  lv_obj_set_event_cb(btnStopLap, stop_lap_event_handler);
+  lv_obj_set_event_cb(btnStopLap, StopLapEventHandler);
   lv_obj_set_size(btnStopLap, btnWidth, btnHeight);
   lv_obj_align(btnStopLap, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
   txtStopLap = lv_label_create(btnStopLap, nullptr);
@@ -146,7 +146,7 @@ void StopWatch::DisplayCleared() {
 }
 
 void StopWatch::RenderTime() {
-  TimeSeparated currentTimeSeparated = convertTicksToTimeSegments(stopWatchController.GetElapsedTime());
+  TimeSeparated currentTimeSeparated = ConvertTicksToTimeSegments(stopWatchController.GetElapsedTime());
   if (currentTimeSeparated.hours == 0) {
     lv_label_set_text_fmt(time, "%02d:%02d", currentTimeSeparated.mins, currentTimeSeparated.secs);
   } else {
@@ -176,14 +176,16 @@ void StopWatch::RenderPause() {
 
 void StopWatch::RenderLaps() {
   lv_label_set_text(lapText, "");
-  for (int i = 0; i < displayedLaps; i++) {
-    LapInfo* lap = stopWatchController.LastLap(i);
+  for (int i = displayedLaps - 1; i >= 0; i--) {
+    std::optional<LapInfo> lap = stopWatchController.LastLap(i);
 
-    if (lap->count != 0) {
-      TimeSeparated laptime = convertTicksToTimeSegments(lap->time);
+    if (lap) {
+      TimeSeparated laptime = ConvertTicksToTimeSegments(lap->time);
       char buffer[16];
       sprintf(buffer, "#%2d   %2d:%02d.%02d\n", lap->count, laptime.mins, laptime.secs, laptime.hundredths);
       lv_label_ins_text(lapText, LV_LABEL_POS_LAST, buffer);
+    } else {
+      lv_label_ins_text(lapText, LV_LABEL_POS_LAST, "\n");
     }
   }
 }