Merge branch 'main' into button-unlock

.devcontainer/Dockerfile

@@ -11,6 +11,7 @@ RUN apt-get update -qq \
       make \
       python3 \
       python3-pip \
+      python3-pil \
       tar \
       unzip \
       wget \ 

.github/workflows/main.yml

@@ -31,6 +31,10 @@ jobs:
         uses: actions/checkout@v3
         with:
           submodules: recursive
+      - name: Install resource build dependencies
+        run:  |
+          apt-get update
+          apt-get -y install --no-install-recommends python3-pil
       - name: Build
         shell: bash
         run: /opt/build.sh all
@@ -61,10 +65,10 @@ jobs:
   build-simulator:
     runs-on: ubuntu-22.04
     steps:
-    - name: Install SDL2 development package
+    - name: Install SDL2 and libpng development package
       run:  |
         sudo apt-get update
-        sudo apt-get -y install libsdl2-dev
+        sudo apt-get -y install libsdl2-dev libpng-dev
 
     - name: Install Ninja
       run:  |
@@ -82,7 +86,7 @@ jobs:
     - name: Get InfiniSim repo
       run:  |
         git clone https://github.com/InfiniTimeOrg/InfiniSim.git --depth 1 --branch main
-        git -C InfiniSim submodule update --init lv_drivers libpng
+        git -C InfiniSim submodule update --init lv_drivers
 
     - name: CMake
       # disable BUILD_RESOURCES as this is already done when building the firmware

CMakeLists.txt

@@ -5,7 +5,7 @@ set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose Debug or Release")
 project(pinetime VERSION 1.13.0 LANGUAGES C CXX ASM)
 
 set(CMAKE_C_STANDARD 99)
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 20)
 
 # set(CMAKE_GENERATOR "Unix Makefiles")
 set(CMAKE_C_EXTENSIONS OFF)

doc/buildAndProgram.md

@@ -42,7 +42,7 @@ CMake configures the project according to variables you specify the command line
 **NRF5_SDK_PATH**|path to the NRF52 SDK|`-DNRF5_SDK_PATH=/home/jf/nrf52/Pinetime/sdk`|
 **CMAKE_BUILD_TYPE (\*)**| Build type (Release or Debug). Release is applied by default if this variable is not specified.|`-DCMAKE_BUILD_TYPE=Debug`
 **BUILD_DFU (\*\*)**|Build DFU files while building (needs [adafruit-nrfutil](https://github.com/adafruit/Adafruit_nRF52_nrfutil)).|`-DBUILD_DFU=1`
-**BUILD_RESOURCES (\*\*)**| Generate external resource while building (needs [lv_font_conv](https://github.com/lvgl/lv_font_conv) and [lv_img_conv](https://github.com/lvgl/lv_img_conv). |`-DBUILD_RESOURCES=1`
+**BUILD_RESOURCES (\*\*)**| Generate external resource while building (needs [lv_font_conv](https://github.com/lvgl/lv_font_conv) and [python3-pil/pillow](https://pillow.readthedocs.io) module). |`-DBUILD_RESOURCES=1`
 **TARGET_DEVICE**|Target device, used for hardware configuration. Allowed: `PINETIME, MOY-TFK5, MOY-TIN5, MOY-TON5, MOY-UNK`|`-DTARGET_DEVICE=PINETIME` (Default)
 
 #### (\*) Note about **CMAKE_BUILD_TYPE**
@@ -98,4 +98,4 @@ Binary files are generated into the folder `src`:
 - **pinetime-mcuboot-app-image** : MCUBoot image of the firmware
 - **pinetime-mcuboot-app-dfu** : DFU file of the firmware
 
-The same files are generated for **pinetime-recovery** and **pinetime-recoveryloader**
+The same files are generated for **pinetime-recovery** and **pinetime-recovery-loader**

doc/code/Apps.md

@@ -9,59 +9,114 @@ This page will teach you:
 
 The user interface of InfiniTime is made up of **screens**.
 Screens that are opened from the app launcher are considered **apps**.
-Every app in InfiniTime is it's own class.
+Every app in InfiniTime is its own class.
 An instance of the class is created when the app is launched, and destroyed when the user exits the app.
-Apps run inside the "displayapp" task (briefly discussed [here](./Intro.md)).
+Apps run inside the `DisplayApp` task (briefly discussed [here](./Intro.md)).
 Apps are responsible for everything drawn on the screen when they are running.
-By default, apps only do something (as in a function is executed) when they are created or when a touch event is detected.
+Apps can be refreshed periodically and reacts to external events (touch or button).
 
 ## Interface
 
-Every app class has to be inside the namespace `Pinetime::Applications::Screens` and inherit from `Screen`.
-The constructor should have at least one parameter `DisplayApp* app`, which it needs for the constructor of its parent class Screen.
-Other parameters should be references to controllers that the app needs.
-A destructor is needed to clean up LVGL and restore any changes (for example re-enable sleeping).
-App classes can override `bool OnButtonPushed()`, `bool OnTouchEvent(TouchEvents event)` and `bool OnTouchEvent(uint16_t x, uint16_t y)` to implement their own functionality for those events.
-If an app only needs to display some text and do something upon a touch screen button press,
-it does not need to override any of these functions, as LVGL can also handle touch events for you.
-If you have any doubts, you can always look at how the other apps function for reference.
+Every app class is declared inside the namespace `Pinetime::Applications::Screens` 
+and inherits
+from [`Pinetime::Applications::Screens::Screen`](https://github.com/InfiniTimeOrg/InfiniTime/blob/main/src/displayapp/screens/Screen.h).
 
-### Continuous updating
+Each app defines its own constructor.
+The constructors mostly take references to InfiniTime `Controllers` (ex: Alarm, DateTime, BLE services, Settings,...)
+the app needs for its operations. The constructor is responsible for initializing the UI of the app.
 
-If your app needs to be updated continuously, you can do so by overriding the `Refresh()` function in your class
-and calling `lv_task_create` inside the constructor.
+The **destructor** cleans up LVGL and restores any changes (for example re-enable sleeping).
 
-An example call could look like this:
+App classes can override `bool OnButtonPushed()`, `bool OnTouchEvent(TouchEvents event)`
+and `bool OnTouchEvent(uint16_t x, uint16_t y)` to implement their own functionality for those events.
 
-```cpp
-taskRefresh = lv_task_create(RefreshTaskCallback, LV_DISP_DEF_REFR_PERIOD, LV_TASK_PRIO_MID, this);
+Apps that need to be refreshed periodically create an `lv_task` (using `lv_task_create()`)
+that will call the method `Refresh()` periodically.
+
+## App types
+
+There are basically 2 types of applications : **system** apps and **user** apps.
+
+**System** applications are always built into InfiniTime, and InfiniTime cannot work properly without those apps.
+The watchfaces, settings, notifications and the application launcher are examples of such system applications.
+
+**User** applications are optionally built into the firmware. They extend the functionalities of the system.
+
+The distinction between **system** and **user** applications allows for more flexibility and customization.
+This allows to easily select which user applications must be built into the firmware
+without overflowing the system memory.
+
+## Apps initialization
+
+Apps are created by `DisplayApp` in `DisplayApp::LoadScreen()`.
+This method simply call the creates an instance of the class that corresponds to the app specified in parameters.
+
+The constructor of **system** apps is called directly. If the application is a **user** app,
+the corresponding `AppDescription` is first retrieved from `userApps`
+and then the function `create` is called to create an instance of the app.
+
+## User application selection at build time
+
+The list of user applications is generated at build time by the `consteval` function `CreateAppDescriptions()`
+in `UserApps.h`. This method takes the list of applications that must be built into the firmware image.
+This list of applications is defined as a list `Apps` enum values named `UserAppTypes` in `Apps.h`.
+For each application listed in `UserAppTypes`, an entry of type `AppDescription` is added to the array `userApps`.
+This entry is created by using the information provided by a template `AppTraits`
+that is customized for every user application.
+
+Here is an example of an AppTraits customized for the Alarm application. 
+It defines the type of application, its icon and a function that returns an instance of the application.
+
+```c++
+template <>
+struct AppTraits<Apps::Alarm> {
+  static constexpr Apps app = Apps::Alarm;
+  static constexpr const char* icon = Screens::Symbols::clock;
+
+  static Screens::Screen* Create(AppControllers& controllers) {
+    return new Screens::Alarm(controllers.alarmController,
+                              controllers.settingsController.GetClockType(),
+                              *controllers.systemTask,
+                              controllers.motorController);
+  };
+};
 ```
 
-With `taskRefresh` being a member variable of your class and of type `lv_task_t*`.
-Remember to delete the task again using `lv_task_del`.
-The function `RefreshTaskCallback` is inherited from `Screen` and just calls your `Refresh` function.
+This array `userApps` is used by `DisplayApp` to create the applications and the `AppLauncher`
+to list all available applications.
 
 ## Creating your own app
 
-A minimal app could look like this:
+A minimal user app could look like this:
 
 MyApp.h:
 
 ```cpp
 #pragma once
 
+#include "displayapp/Apps.h"
 #include "displayapp/screens/Screen.h"
-#include <lvgl/lvgl.h>
+#include "displayapp/Controllers.h"
+#include "Symbols.h"
 
 namespace Pinetime {
   namespace Applications {
     namespace Screens {
       class MyApp : public Screen {
       public:
-        MyApp(DisplayApp* app);
+        MyApp();
         ~MyApp() override;
       };
     }
+    
+    template <>
+    struct AppTraits<Apps:MyApp> {
+      static constexpr Apps app = Apps::MyApp;
+      static constexpr const char* icon = Screens::Symbol::myApp;
+      static Screens::Screens* Create(AppController& controllers) {
+        return new Screens::MyApp();
+      }
+    };
   }
 }
 ```
@@ -70,11 +125,10 @@ MyApp.cpp:
 
 ```cpp
 #include "displayapp/screens/MyApp.h"
-#include "displayapp/DisplayApp.h"
 
 using namespace Pinetime::Applications::Screens;
 
-MyApp::MyApp(DisplayApp* app) : Screen(app) {
+MyApp::MyApp() {
   lv_obj_t* title = lv_label_create(lv_scr_act(), nullptr);
   lv_label_set_text_static(title, "My test application");
   lv_label_set_align(title, LV_LABEL_ALIGN_CENTER);
@@ -86,20 +140,24 @@ MyApp::~MyApp() {
 }
 ```
 
-Both of these files should be in [displayapp/screens/](/src/displayapp/screens/)
-or [displayapp/screens/settings/](/src/displayapp/screens/settings/) if it's a setting app.
+Both of these files should be in [displayapp/screens/](/src/displayapp/screens/).
 
 Now we have our very own app, but InfiniTime does not know about it yet.
-The first step is to include your MyApp.cpp (or any new cpp files for that matter)
+The first step is to include your `MyApp.cpp` (or any new cpp files for that matter)
 in the compilation by adding it to [CMakeLists.txt](/CMakeLists.txt).
-The next step to making it launchable is to give your app an id.
+The next step to making it launch-able is to give your app an id.
 To do this, add an entry in the enum class `Pinetime::Applications::Apps` ([displayapp/Apps.h](/src/displayapp/Apps.h)).
-Name this entry after your app. Add `#include "displayapp/screens/MyApp.h"` to the file [displayapp/DisplayApp.cpp](/src/displayapp/DisplayApp.cpp).
-Now, go to the function `DisplayApp::LoadScreen` and add another case to the switch statement.
+Name this entry after your app. Add `#include "displayapp/screens/MyApp.h"`
+to the file [displayapp/DisplayApp.cpp](/src/displayapp/DisplayApp.cpp).
+
+If your application is a **system** application, go to the function `DisplayApp::LoadScreen`
+and add another case to the switch statement.
 The case will be the id you gave your app earlier.
 If your app needs any additional arguments, this is the place to pass them.
 
-If you want to add your app in the app launcher, add your app in [displayapp/screens/ApplicationList.h](/src/displayapp/screens/ApplicationList.h) to the array containing the applications and their corresponding symbol. If your app is a setting, do the same procedure in [displayapp/screens/settings/Settings.h](/src/displayapp/screens/settings/Settings.h).
+If your application is a **user** application, you don't need to add anything in DisplayApp,
+everything will be automatically generated for you.
+The user application will also be automatically be added to the app launcher menu.
 
 You should now be able to [build](../buildAndProgram.md) the firmware
 and flash it to your PineTime. Yay!

docker/Dockerfile

@@ -1,21 +1,28 @@
 FROM ubuntu:22.04
 
 ARG DEBIAN_FRONTEND=noninteractive
+ARG NODE_MAJOR=20
 RUN apt-get update -qq \
+    && apt-get install -y ca-certificates curl gnupg \
+    && mkdir -p /etc/apt/keyrings \
+    && curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg \
+    && echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" > /etc/apt/sources.list.d/nodesource.list \
+    && apt-get update -qq \
     && apt-get install -y \
 # x86_64 / generic packages
       bash \
       build-essential \
       cmake \
       git \
       make \
+      nodejs \
       python3 \
       python3-pip \
+      python3-pil \
       python-is-python3 \
       tar \
       unzip \
       wget \
-      curl \
       # aarch64 packages
       libffi-dev \
       libssl-dev \
@@ -28,8 +35,6 @@ RUN apt-get update -qq \
       libpango-1.0-0 \
       ibpango1.0-dev \
       libpangocairo-1.0-0 \
-    && curl -sL https://deb.nodesource.com/setup_18.x | bash - \
-    && apt-get install -y nodejs \
     && rm -rf /var/cache/apt/* /var/lib/apt/lists/*;
 
 # Git needed for PROJECT_GIT_COMMIT_HASH variable setting
@@ -39,10 +44,6 @@ RUN pip3 install -Iv cryptography==3.3
 RUN pip3 install cbor
 RUN npm i [email protected] -g
 
-RUN npm i [email protected] -g
-RUN npm i @swc/core -g
-RUN npm i [email protected] -g
-
 # build.sh knows how to compile
 COPY build.sh /opt/
 

src/CMakeLists.txt

@@ -394,7 +394,6 @@ list(APPEND SOURCE_FILES
         displayapp/screens/Notifications.cpp
         displayapp/screens/Twos.cpp
         displayapp/screens/HeartRate.cpp
-        displayapp/screens/Motion.cpp
         displayapp/screens/FlashLight.cpp
         displayapp/screens/List.cpp
         displayapp/screens/CheckboxList.cpp

src/components/ble/weather/WeatherService.cpp

@@ -404,7 +404,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Clouds>& WeatherService::GetCurrentClouds() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Clouds && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Clouds && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Clouds>&>(header);
         }
       }
@@ -415,7 +416,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Obscuration>& WeatherService::GetCurrentObscuration() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Obscuration && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Obscuration && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Obscuration>&>(header);
         }
       }
@@ -426,7 +428,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Precipitation>& WeatherService::GetCurrentPrecipitation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Precipitation && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Precipitation && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Precipitation>&>(header);
         }
       }
@@ -437,7 +440,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Wind>& WeatherService::GetCurrentWind() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Wind && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Wind && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Wind>&>(header);
         }
       }
@@ -448,7 +452,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Temperature>& WeatherService::GetCurrentTemperature() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Temperature && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Temperature && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Temperature>&>(header);
         }
       }
@@ -459,7 +464,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Humidity>& WeatherService::GetCurrentHumidity() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Humidity && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Humidity && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Humidity>&>(header);
         }
       }
@@ -470,7 +476,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Pressure>& WeatherService::GetCurrentPressure() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Pressure && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Pressure && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Pressure>&>(header);
         }
       }
@@ -481,7 +488,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::Location>& WeatherService::GetCurrentLocation() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::Location && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::Location && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::Location>&>(header);
         }
       }
@@ -492,7 +500,8 @@ namespace Pinetime {
     std::unique_ptr<WeatherData::AirQuality>& WeatherService::GetCurrentQuality() {
       uint64_t currentTimestamp = GetCurrentUnixTimestamp();
       for (auto&& header : this->timeline) {
-        if (header->eventType == WeatherData::eventtype::AirQuality && IsEventStillValid(header, currentTimestamp)) {
+        if (header->eventType == WeatherData::eventtype::AirQuality && currentTimestamp >= header->timestamp &&
+            IsEventStillValid(header, currentTimestamp)) {
           return reinterpret_cast<std::unique_ptr<WeatherData::AirQuality>&>(header);
         }
       }