Merge branch 'develop' of JF/PineTime into master

17 files changed, 504 insertions, 56 deletions

diff --git a/src/DisplayApp/Screens/BatteryIcon.cpp b/src/DisplayApp/Screens/BatteryIcon.cpp
new file mode 100644
index 00000000..e20167d8
--- /dev/null
+++ b/src/DisplayApp/Screens/BatteryIcon.cpp
@@ -0,0 +1,62 @@
+#include "BatteryIcon.h"
+
+using namespace Pinetime::Applications::Screens;
+
+
+extern lv_img_dsc_t ck_os_battery_error;
+extern lv_img_dsc_t ck_os_batterycharging_100;
+extern lv_img_dsc_t ck_os_batterycharging_090;
+extern lv_img_dsc_t ck_os_batterycharging_080;
+extern lv_img_dsc_t ck_os_batterycharging_070;
+extern lv_img_dsc_t ck_os_batterycharging_060;
+extern lv_img_dsc_t ck_os_batterycharging_050;
+extern lv_img_dsc_t ck_os_batterycharging_040;
+extern lv_img_dsc_t ck_os_batterycharging_030;
+extern lv_img_dsc_t ck_os_batterycharging_020;
+extern lv_img_dsc_t ck_os_batterycharging_010;
+extern lv_img_dsc_t ck_os_batterycharging_005;
+
+extern lv_img_dsc_t ck_os_battery_100;
+extern lv_img_dsc_t ck_os_battery_090;
+extern lv_img_dsc_t ck_os_battery_080;
+extern lv_img_dsc_t ck_os_battery_070;
+extern lv_img_dsc_t ck_os_battery_060;
+extern lv_img_dsc_t ck_os_battery_050;
+extern lv_img_dsc_t ck_os_battery_040;
+extern lv_img_dsc_t ck_os_battery_030;
+extern lv_img_dsc_t ck_os_battery_020;
+extern lv_img_dsc_t ck_os_battery_010;
+extern lv_img_dsc_t ck_os_battery_005;
+
+
+lv_img_dsc_t *BatteryIcon::GetIcon(bool isCharging, float batteryPercent) {
+  if(isCharging) {
+    if(batteryPercent > 90.0f) return &ck_os_batterycharging_100;
+    else if(batteryPercent > 80.0f) return &ck_os_batterycharging_090;
+    else if(batteryPercent > 70.0f) return &ck_os_batterycharging_080;
+    else if(batteryPercent > 60.0f) return &ck_os_batterycharging_070;
+    else if(batteryPercent > 50.0f) return &ck_os_batterycharging_060;
+    else if(batteryPercent > 40.0f) return &ck_os_batterycharging_050;
+    else if(batteryPercent > 30.0f) return &ck_os_batterycharging_040;
+    else if(batteryPercent > 20.0f) return &ck_os_batterycharging_030;
+    else if(batteryPercent > 10.0f) return &ck_os_batterycharging_020;
+    else if(batteryPercent > 5.0f) return &ck_os_batterycharging_010;
+    else return &ck_os_batterycharging_005;
+  } else {
+    if(batteryPercent > 90.0f) return &ck_os_battery_100;
+    else if(batteryPercent > 80.0f) return &ck_os_battery_090;
+    else if(batteryPercent > 70.0f) return &ck_os_battery_080;
+    else if(batteryPercent > 60.0f) return &ck_os_battery_070;
+    else if(batteryPercent > 50.0f) return &ck_os_battery_060;
+    else if(batteryPercent > 40.0f) return &ck_os_battery_050;
+    else if(batteryPercent > 30.0f) return &ck_os_battery_040;
+    else if(batteryPercent > 20.0f) return &ck_os_battery_030;
+    else if(batteryPercent > 10.0f) return &ck_os_battery_020;
+    else if(batteryPercent > 5.0f) return &ck_os_battery_010;
+    else return &ck_os_battery_005;
+  }
+}
+
+lv_img_dsc_t *BatteryIcon::GetUnknownIcon() {
+  return &ck_os_battery_error;
+}
diff --git a/src/DisplayApp/Screens/BatteryIcon.h b/src/DisplayApp/Screens/BatteryIcon.h
new file mode 100644
index 00000000..4e2a3a03
--- /dev/null
+++ b/src/DisplayApp/Screens/BatteryIcon.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <libs/lvgl/src/lv_draw/lv_img_decoder.h>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class BatteryIcon {
+      public:
+        static lv_img_dsc_t* GetUnknownIcon();
+        static lv_img_dsc_t* GetIcon(bool isCharging, float batteryPercent);
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/BleIcon.cpp b/src/DisplayApp/Screens/BleIcon.cpp
new file mode 100644
index 00000000..28a7727c
--- /dev/null
+++ b/src/DisplayApp/Screens/BleIcon.cpp
@@ -0,0 +1,12 @@
+#include "BleIcon.h"
+
+using namespace Pinetime::Applications::Screens;
+
+
+extern lv_img_dsc_t ck_os_bt_connected;
+extern lv_img_dsc_t ck_os_bt_disconnected;
+
+lv_img_dsc_t *BleIcon::GetIcon(bool isConnected) {
+  if(isConnected) return &ck_os_bt_connected;
+  else return &ck_os_bt_disconnected;
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/BleIcon.h b/src/DisplayApp/Screens/BleIcon.h
new file mode 100644
index 00000000..ee090f96
--- /dev/null
+++ b/src/DisplayApp/Screens/BleIcon.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <libs/lvgl/src/lv_draw/lv_img_decoder.h>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class BleIcon {
+      public:
+        static lv_img_dsc_t* GetIcon(bool isConnected);
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/Brightness.cpp b/src/DisplayApp/Screens/Brightness.cpp
new file mode 100644
index 00000000..9e3416c0
--- /dev/null
+++ b/src/DisplayApp/Screens/Brightness.cpp
@@ -0,0 +1,92 @@
+#include <libs/lvgl/lvgl.h>
+#include "Brightness.h"
+
+using namespace Pinetime::Applications::Screens;
+
+void slider_event_cb(lv_obj_t * slider, lv_event_t event) {
+  if(event == LV_EVENT_VALUE_CHANGED) {
+    auto* brightnessSlider = static_cast<Brightness*>(slider->user_data);
+    brightnessSlider->OnValueChanged();
+  }
+}
+
+Brightness::Brightness(Pinetime::Applications::DisplayApp *app, Controllers::BrightnessController& brightness) : Screen(app), brightness{brightness} {
+  slider = lv_slider_create(lv_scr_act(), NULL);
+  lv_obj_set_user_data(slider, this);
+  lv_obj_set_width(slider, LV_DPI * 2);
+  lv_obj_align(slider, NULL, LV_ALIGN_CENTER, 0, 0);
+  lv_obj_set_event_cb(slider, slider_event_cb);
+  lv_slider_set_range(slider, 0, 2);
+  lv_slider_set_value(slider, LevelToInt(brightness.Level()), LV_ANIM_OFF);
+
+  slider_label = lv_label_create(lv_scr_act(), NULL);
+  lv_label_set_text(slider_label, LevelToString(brightness.Level()));
+  lv_obj_set_auto_realign(slider_label, true);
+  lv_obj_align(slider_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
+}
+
+Brightness::~Brightness() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool Brightness::Refresh() {
+  return running;
+}
+
+bool Brightness::OnButtonPushed() {
+  running = false;
+  return true;
+}
+
+const char *Brightness::LevelToString(Pinetime::Controllers::BrightnessController::Levels level) {
+  switch(level) {
+    case Pinetime::Controllers::BrightnessController::Levels::Off: return "Off";
+    case Pinetime::Controllers::BrightnessController::Levels::Low: return "Low";
+    case Pinetime::Controllers::BrightnessController::Levels::Medium: return "Medium";
+    case Pinetime::Controllers::BrightnessController::Levels::High: return "High";
+    default : return "???";
+  }
+}
+
+void Brightness::OnValueChanged() {
+  SetValue(lv_slider_get_value(slider));
+}
+
+void Brightness::SetValue(uint8_t value) {
+  switch(value) {
+    case 0: brightness.Set(Controllers::BrightnessController::Levels::Low); break;
+    case 1: brightness.Set(Controllers::BrightnessController::Levels::Medium); break;
+    case 2: brightness.Set(Controllers::BrightnessController::Levels::High); break;
+  }
+  lv_label_set_text(slider_label, LevelToString(brightness.Level()));
+}
+
+uint8_t Brightness::LevelToInt(Pinetime::Controllers::BrightnessController::Levels level) {
+  switch(level) {
+    case Pinetime::Controllers::BrightnessController::Levels::Off: return 0;
+    case Pinetime::Controllers::BrightnessController::Levels::Low: return 0;
+    case Pinetime::Controllers::BrightnessController::Levels::Medium: return 1;
+    case Pinetime::Controllers::BrightnessController::Levels::High: return 2;
+    default : return 0;
+  }
+}
+
+bool Brightness::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  switch(event) {
+    case TouchEvents::SwipeLeft:
+      brightness.Lower();
+      SetValue();
+      return true;
+    case TouchEvents::SwipeRight:
+      brightness.Higher();
+      SetValue();
+      return true;
+    default:
+      return false;
+  }
+}
+
+void Brightness::SetValue() {
+  lv_slider_set_value(slider, LevelToInt(brightness.Level()), LV_ANIM_OFF);
+  lv_label_set_text(slider_label, LevelToString(brightness.Level()));
+}
diff --git a/src/DisplayApp/Screens/Brightness.h b/src/DisplayApp/Screens/Brightness.h
new file mode 100644
index 00000000..37cbcd7e
--- /dev/null
+++ b/src/DisplayApp/Screens/Brightness.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <libs/lvgl/src/lv_core/lv_obj.h>
+#include <Components/Brightness/BrightnessController.h>
+#include "Screen.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class Brightness : public Screen {
+        public:
+          Brightness(DisplayApp* app, Controllers::BrightnessController& brightness);
+          ~Brightness() override;
+          bool Refresh() override;
+          bool OnButtonPushed() override;
+          bool OnTouchEvent(TouchEvents event) override;
+
+          void OnValueChanged();
+        private:
+          bool running = true;
+          Controllers::BrightnessController& brightness;
+
+          lv_obj_t * slider_label;
+          lv_obj_t * slider;
+
+          const char* LevelToString(Controllers::BrightnessController::Levels level);
+          uint8_t LevelToInt(Controllers::BrightnessController::Levels level);
+          void SetValue(uint8_t value);
+          void SetValue();
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/Clock.cpp b/src/DisplayApp/Screens/Clock.cpp
index abc4d627..07db83ee 100644
--- a/src/DisplayApp/Screens/Clock.cpp
+++ b/src/DisplayApp/Screens/Clock.cpp
@@ -5,11 +5,14 @@
 #include <libs/lvgl/lvgl.h>
 #include "Clock.h"
 #include "../DisplayApp.h"
+#include "BatteryIcon.h"
+#include "BleIcon.h"
 
 using namespace Pinetime::Applications::Screens;
 extern lv_font_t jetbrains_mono_extrabold_compressed;
 extern lv_font_t jetbrains_mono_bold_20;
 
+
 static void event_handler(lv_obj_t * obj, lv_event_t event) {
   Clock* screen = static_cast<Clock *>(obj->user_data);
   screen->OnObjectEvent(obj, event);
@@ -26,30 +29,30 @@ Clock::Clock(DisplayApp* app,
   displayedChar[3] = 0;
   displayedChar[4] = 0;
 
-  label_battery = lv_label_create(lv_scr_act(), NULL);
-  lv_obj_align(label_battery, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, -80, 0);
+  batteryIcon = lv_img_create(lv_scr_act(), NULL);
+  lv_img_set_src(batteryIcon, BatteryIcon::GetUnknownIcon());
+  lv_obj_align(batteryIcon, lv_scr_act(), LV_ALIGN_IN_TOP_RIGHT, 0, 0);
+
+  bleIcon = lv_img_create(lv_scr_act(), NULL);
+  lv_img_set_src(bleIcon, BleIcon::GetIcon(false));
+  lv_obj_align(bleIcon, batteryIcon, LV_ALIGN_OUT_LEFT_MID, 0, 0);
+
+  label_date = lv_label_create(lv_scr_act(), NULL);
 
-  labelStyle = const_cast<lv_style_t *>(lv_label_get_style(label_battery, LV_LABEL_STYLE_MAIN));
+  lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 60);
+
+  labelStyle = const_cast<lv_style_t *>(lv_label_get_style(label_date, LV_LABEL_STYLE_MAIN));
   labelStyle->text.font = &jetbrains_mono_bold_20;
 
   lv_style_copy(&labelBigStyle, labelStyle);
   labelBigStyle.text.font = &jetbrains_mono_extrabold_compressed;
 
-  lv_label_set_style(label_battery, LV_LABEL_STYLE_MAIN, labelStyle);
-
-  label_ble = lv_label_create(lv_scr_act(), NULL);
-  lv_label_set_style(label_ble, LV_LABEL_STYLE_MAIN, labelStyle);
-  lv_obj_align(label_ble, lv_scr_act(), LV_ALIGN_IN_TOP_LEFT, 10, 0);
+  lv_label_set_style(label_date, LV_LABEL_STYLE_MAIN, labelStyle);
 
   label_time = lv_label_create(lv_scr_act(), NULL);
   lv_label_set_style(label_time, LV_LABEL_STYLE_MAIN, &labelBigStyle);
   lv_obj_align(label_time, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 0);
 
-
-  label_date = lv_label_create(lv_scr_act(), NULL);
-  lv_label_set_style(label_date, LV_LABEL_STYLE_MAIN, labelStyle);
-  lv_obj_align(label_date, lv_scr_act(), LV_ALIGN_IN_LEFT_MID, 0, 60);
-
   backgroundLabel = lv_label_create(lv_scr_act(), NULL);
   backgroundLabel->user_data = this;
   lv_label_set_style(backgroundLabel, LV_LABEL_STYLE_MAIN, labelStyle);
@@ -68,22 +71,16 @@ Clock::~Clock() {
 bool Clock::Refresh() {
   batteryPercentRemaining = batteryController.PercentRemaining();
   if (batteryPercentRemaining.IsUpdated()) {
-    char batteryChar[11];
-    auto newBatteryValue = batteryPercentRemaining.Get();
-    newBatteryValue = (newBatteryValue > 100) ? 100 : newBatteryValue;
-    newBatteryValue = (newBatteryValue < 0) ? 0 : newBatteryValue;
-
-    sprintf(batteryChar, "BAT: %d%%", newBatteryValue);
-    lv_label_set_text(label_battery, batteryChar);
+    auto batteryPercent = batteryPercentRemaining.Get();
+    lv_img_set_src(batteryIcon, BatteryIcon::GetIcon(batteryController.IsCharging() || batteryController.IsPowerPresent(), batteryPercent));
   }
 
   bleState = bleController.IsConnected();
   if (bleState.IsUpdated()) {
     if(bleState.Get() == true) {
-      lv_obj_set_hidden(label_ble, false);
-      lv_label_set_text(label_ble, "BLE");
+      lv_img_set_src(bleIcon, BleIcon::GetIcon(true));
     } else {
-      lv_obj_set_hidden(label_ble, true);
+      lv_img_set_src(bleIcon, BleIcon::GetIcon(false));
     }
   }
 
diff --git a/src/DisplayApp/Screens/Clock.h b/src/DisplayApp/Screens/Clock.h
index d14595b0..7c4a09df 100644
--- a/src/DisplayApp/Screens/Clock.h
+++ b/src/DisplayApp/Screens/Clock.h
@@ -76,6 +76,9 @@ namespace Pinetime {
           lv_obj_t* label_version;
           lv_obj_t* backgroundLabel;
 
+          lv_obj_t * batteryIcon;
+          lv_obj_t * bleIcon;
+
           Controllers::DateTime& dateTimeController;
           Controllers::Battery& batteryController;
           Controllers::Ble& bleController;
diff --git a/src/DisplayApp/Screens/Label.cpp b/src/DisplayApp/Screens/Label.cpp
new file mode 100644
index 00000000..ba35279d
--- /dev/null
+++ b/src/DisplayApp/Screens/Label.cpp
@@ -0,0 +1,28 @@
+#include <libs/lvgl/lvgl.h>
+#include "Label.h"
+
+using namespace Pinetime::Applications::Screens;
+
+
+Label::Label(const char* text) : text{text} {
+
+}
+
+Label::~Label() {
+
+}
+
+void Label::Refresh() {
+
+}
+
+void Label::Show() {
+  label = lv_label_create(lv_scr_act(), NULL);
+  lv_label_set_align(label, LV_LABEL_ALIGN_LEFT);
+  lv_obj_set_size(label, 240, 240);
+  lv_label_set_text(label, text);
+}
+
+void Label::Hide() {
+  lv_obj_clean(lv_scr_act());
+}
diff --git a/src/DisplayApp/Screens/Label.h b/src/DisplayApp/Screens/Label.h
new file mode 100644
index 00000000..b73540f4
--- /dev/null
+++ b/src/DisplayApp/Screens/Label.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <vector>
+#include "Screen.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class Label {
+        public:
+          Label() = default;
+          explicit Label(const char* text);
+          ~Label();
+          void Refresh();
+
+          void Hide();
+          void Show();
+        private:
+          lv_obj_t * label = nullptr;
+          const char* text = nullptr;
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/Modal.cpp b/src/DisplayApp/Screens/Modal.cpp
index fc353c49..63ae70c0 100644
--- a/src/DisplayApp/Screens/Modal.cpp
+++ b/src/DisplayApp/Screens/Modal.cpp
@@ -25,7 +25,31 @@ bool Modal::OnButtonPushed() {
   return true;
 }
 
-void Modal::Show() {
+void Modal::Hide() {
+  /* Delete the parent modal background */
+  lv_obj_del_async(lv_obj_get_parent(mbox));
+  mbox = NULL; /* happens before object is actually deleted! */
+  isVisible = false;
+}
+
+void Modal::mbox_event_cb(lv_obj_t *obj, lv_event_t evt) {
+  auto* m = static_cast<Modal *>(obj->user_data);
+  m->OnEvent(obj, evt);
+}
+
+void Modal::OnEvent(lv_obj_t *event_obj, lv_event_t evt) {
+  if(evt == LV_EVENT_DELETE && event_obj == mbox) {
+    Hide();
+  } else if(evt == LV_EVENT_VALUE_CHANGED) {
+    /* A button was clicked */
+    lv_mbox_start_auto_close(mbox, 0);
+//    Hide();
+  }
+}
+
+void Modal::Show(const char* msg) {
+  if(isVisible) return;
+  isVisible = true;
   lv_style_copy(&modal_style, &lv_style_plain_color);
   modal_style.body.main_color = modal_style.body.grad_color = LV_COLOR_BLACK;
   modal_style.body.opa = LV_OPA_50;
@@ -41,10 +65,7 @@ void Modal::Show() {
   /* Create the message box as a child of the modal background */
   mbox = lv_mbox_create(obj, NULL);
   lv_mbox_add_btns(mbox, btns2);
-  char versionStr[20];
-  sprintf(versionStr, "VERSION: %d.%d.%d", Version::Major(), Version::Minor(), Version::Patch());
-  lv_mbox_set_text(mbox, versionStr);
-//  lv_mbox_set_text(mbox, "Hello world!");
+  lv_mbox_set_text(mbox, msg);
   lv_obj_align(mbox, NULL, LV_ALIGN_CENTER, 0, 0);
   lv_obj_set_event_cb(mbox, Modal::mbox_event_cb);
 
@@ -58,24 +79,3 @@ void Modal::Show() {
   lv_anim_set_exec_cb(&a, obj, (lv_anim_exec_xcb_t)lv_obj_set_opa_scale);
   lv_anim_create(&a);
 }
-
-void Modal::Hide() {
-  /* Delete the parent modal background */
-  lv_obj_del_async(lv_obj_get_parent(mbox));
-  mbox = NULL; /* happens before object is actually deleted! */
-}
-
-void Modal::mbox_event_cb(lv_obj_t *obj, lv_event_t evt) {
-  auto* m = static_cast<Modal *>(obj->user_data);
-  m->OnEvent(obj, evt);
-}
-
-void Modal::OnEvent(lv_obj_t *event_obj, lv_event_t evt) {
-  if(evt == LV_EVENT_DELETE && event_obj == mbox) {
-    Hide();
-  } else if(evt == LV_EVENT_VALUE_CHANGED) {
-    /* A button was clicked */
-    lv_mbox_start_auto_close(mbox, 0);
-//    Hide();
-  }
-}
diff --git a/src/DisplayApp/Screens/Modal.h b/src/DisplayApp/Screens/Modal.h
index de287293..b5425906 100644
--- a/src/DisplayApp/Screens/Modal.h
+++ b/src/DisplayApp/Screens/Modal.h
@@ -22,7 +22,7 @@ namespace Pinetime {
           Modal(DisplayApp* app);
           ~Modal() override;
 
-          void Show();
+          void Show(const char* msg);
           void Hide();
 
           bool Refresh() override;
@@ -37,6 +37,7 @@ namespace Pinetime {
           lv_obj_t *mbox;
           lv_obj_t *info;
           bool running = true;
+          bool isVisible = false;
 
       };
     }
diff --git a/src/DisplayApp/Screens/Screen.h b/src/DisplayApp/Screens/Screen.h
index 6cbd41ad..d8902317 100644
--- a/src/DisplayApp/Screens/Screen.h
+++ b/src/DisplayApp/Screens/Screen.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "../TouchEvents.h"
 
 namespace Pinetime {
   namespace Applications {
@@ -15,6 +16,9 @@ namespace Pinetime {
           // Return false if the button hasn't been handled by the app, true if it has been handled
           virtual bool OnButtonPushed() { return false; }
 
+          // Return false if the event hasn't been handled by the app, true if it has been handled
+          virtual bool OnTouchEvent(TouchEvents event) { return false; }
+
         protected:
           DisplayApp* app;
       };
diff --git a/src/DisplayApp/Screens/ScreenList.cpp b/src/DisplayApp/Screens/ScreenList.cpp
new file mode 100644
index 00000000..93a91212
--- /dev/null
+++ b/src/DisplayApp/Screens/ScreenList.cpp
@@ -0,0 +1,115 @@
+#include <libs/lvgl/lvgl.h>
+#include <DisplayApp/DisplayApp.h>
+#include "ScreenList.h"
+
+using namespace Pinetime::Applications::Screens;
+
+// TODO this class must be improved to receive the list of "sub screens" via pointer or
+// move operation.
+// It should accept many type of "sub screen" (it only supports Label for now).
+// The number of sub screen it supports must be dynamic.
+ScreenList::ScreenList(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::DateTime &dateTimeController,
+        Pinetime::Controllers::Battery& batteryController, Pinetime::Controllers::BrightnessController& brightnessController, Pinetime::Drivers::WatchdogView& watchdog) :
+        Screen(app),
+        dateTimeController{dateTimeController}, batteryController{batteryController}, brightnessController{brightnessController}, watchdog{watchdog} {
+  screens.reserve(3);
+
+  // TODO all of this is far too heavy (string processing). This should be improved.
+  // TODO the info (battery, time,...) should be updated in the Refresh method.
+
+
+  auto batteryPercent = static_cast<int16_t>(batteryController.PercentRemaining());
+  if(batteryPercent > 100) batteryPercent = 100;
+  else if(batteryPercent < 0) batteryPercent = 0;
+
+  uint8_t brightness = 0;
+  switch(brightnessController.Level()) {
+    case Controllers::BrightnessController::Levels::Low: brightness = 1; break;
+    case Controllers::BrightnessController::Levels::Medium: brightness = 2; break;
+    case Controllers::BrightnessController::Levels::High: brightness = 3; break;
+  }
+  auto resetReason = [&watchdog]() {
+    switch (watchdog.ResetReason()) {
+      case Drivers::Watchdog::ResetReasons::Watchdog: return "wtdg";
+      case Drivers::Watchdog::ResetReasons::HardReset: return "hardr";
+      case Drivers::Watchdog::ResetReasons::NFC: return "nfc";
+      case Drivers::Watchdog::ResetReasons::SoftReset: return "softr";
+      case Drivers::Watchdog::ResetReasons::CpuLockup: return "cpulock";
+      case Drivers::Watchdog::ResetReasons::SystemOff: return "off";
+      case Drivers::Watchdog::ResetReasons::LpComp: return "lpcomp";
+      case Drivers::Watchdog::ResetReasons::DebugInterface: return "dbg";
+      case Drivers::Watchdog::ResetReasons::ResetPin: return "rst";
+      default: return "?";
+    }
+  }();
+
+
+  sprintf(t1, "Pinetime\n"
+              "Version:%d.%d.%d\n"
+              "Build: xx/xx/xxxx\n"
+              "Time: %02d:%02d:%02d\n"
+              "date: %02d/%02d/%04d\n"
+              "Uptime: xd xxhxx:xx\n"
+              "Battery: %d%%\n"
+              "Backlight: %d/3\n"
+              "Last reset: %s\n"
+              "BLE MAC: \n  AA:BB:CC:DD:EE:FF", Version::Major(), Version::Minor(), Version::Patch(),
+              dateTimeController.Hours(), dateTimeController.Minutes(), dateTimeController.Seconds(),
+              dateTimeController.Day(), dateTimeController.Month(), dateTimeController.Year(),
+              batteryPercent, brightness, resetReason);
+
+  screens.emplace_back(t1);
+
+  strncpy(t2, "Hello from\nthe developper!", 27);
+  screens.emplace_back(t2);
+
+  strncpy(t3, "Place holder\nin case we need\nmore room!", 40);
+  screens.emplace_back(t3);
+
+  auto &screen = screens[screenIndex];
+  screen.Show();
+}
+
+ScreenList::~ScreenList() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool ScreenList::Refresh() {
+  auto &screen = screens[screenIndex];
+  screen.Refresh();
+
+  return running;
+}
+
+bool ScreenList::OnButtonPushed() {
+  running = false;
+  return true;
+}
+
+bool ScreenList::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
+  switch (event) {
+    case TouchEvents::SwipeDown:
+      if (screenIndex > 0) {
+        app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
+        auto &oldScreen = screens[screenIndex];
+        oldScreen.Hide();
+        screenIndex--;
+        auto &newScreen = screens[screenIndex];
+        newScreen.Show();
+      }
+      return true;
+    case TouchEvents::SwipeUp:
+      app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
+      if (screenIndex < screens.size() - 1) {
+        auto &oldScreen = screens[screenIndex];
+        oldScreen.Hide();
+        screenIndex++;
+        auto &newScreen = screens[screenIndex];
+        newScreen.Show();
+      }
+      return true;
+    default:
+      return false;
+  }
+  return false;
+}
diff --git a/src/DisplayApp/Screens/ScreenList.h b/src/DisplayApp/Screens/ScreenList.h
new file mode 100644
index 00000000..ad093d35
--- /dev/null
+++ b/src/DisplayApp/Screens/ScreenList.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <vector>
+#include "Screen.h"
+#include "Label.h"
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+      class ScreenList : public Screen {
+        public:
+          explicit ScreenList(DisplayApp* app,
+                              Pinetime::Controllers::DateTime& dateTimeController,
+                              Pinetime::Controllers::Battery& batteryController,
+                              Pinetime::Controllers::BrightnessController& brightnessController,
+                              Pinetime::Drivers::WatchdogView& watchdog);
+          ~ScreenList() override;
+          bool Refresh() override;
+          bool OnButtonPushed() override;
+          bool OnTouchEvent(TouchEvents event) override;
+        private:
+          bool running = true;
+          uint8_t screenIndex = 0;
+
+          // TODO choose another container without dynamic alloc
+          std::vector<Screens::Label> screens;
+          Pinetime::Controllers::DateTime& dateTimeController;
+          Pinetime::Controllers::Battery& batteryController;
+          Pinetime::Controllers::BrightnessController& brightnessController;
+          Pinetime::Drivers::WatchdogView& watchdog;
+
+          char t1[200];
+          char t2[30];
+          char t3[42];
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/DisplayApp/Screens/Tile.cpp b/src/DisplayApp/Screens/Tile.cpp
index 004c8d31..6c225c9d 100644
--- a/src/DisplayApp/Screens/Tile.cpp
+++ b/src/DisplayApp/Screens/Tile.cpp
@@ -16,7 +16,7 @@ static void event_handler(lv_obj_t * obj, lv_event_t event) {
   screen->OnObjectEvent(obj, event, eventData);
 }
 
-static const char * btnm_map1[] = {"Meter", "Gauge", "Clock", "\n", "Soft\nversion", "App2", "App3", ""};
+static const char * btnm_map1[] = {"Meter", "Gauge", "Clock", "\n", "Soft\nversion", "App2", "Brightness", ""};
 
 Tile::Tile(DisplayApp* app) : Screen(app) {
   modal.reset(new Modal(app));
@@ -123,11 +123,15 @@ void Tile::OnObjectEvent(lv_obj_t *obj, lv_event_t event, uint32_t buttonId) {
         tile->StartClockApp();
         break;
       case 3:
-        modal->Show();
+        char versionStr[20];
+        sprintf(versionStr, "VERSION: %d.%d.%d", Version::Major(), Version::Minor(), Version::Patch());
+        modal->Show(versionStr);
         break;
       case 4:
+        tile->StartSysInfoApp();
+        break;
       case 5:
-        tile->StartTestApp();
+        tile->StartBrightnessApp();
 
         break;
     }
@@ -146,8 +150,13 @@ void Tile::StartClockApp() {
   running = false;
 }
 
-void Tile::StartTestApp() {
-  app->StartApp(DisplayApp::Apps::Test);
+void Tile::StartSysInfoApp() {
+  app->StartApp(DisplayApp::Apps::SysInfo);
+  running = false;
+}
+
+void Tile::StartBrightnessApp() {
+  app->StartApp(DisplayApp::Apps::Brightness);
   running = false;
 }
 
diff --git a/src/DisplayApp/Screens/Tile.h b/src/DisplayApp/Screens/Tile.h
index eb253435..fa2d6db0 100644
--- a/src/DisplayApp/Screens/Tile.h
+++ b/src/DisplayApp/Screens/Tile.h
@@ -52,12 +52,13 @@ namespace Pinetime {
           uint32_t clickCount = 0 ;
           uint32_t previousClickCount = 0;
           void StartClockApp();
-          void StartTestApp();
+          void StartSysInfoApp();
           void StartMeterApp();
           void StartGaugeApp();
           bool running = true;
 
           std::unique_ptr<Modal> modal;
+          void StartBrightnessApp();
       };
     }
   }