Merge pull request #40 from piggz/music

Music

13 files changed, 425 insertions, 7 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e60c2cfe..2d6d6e8e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -336,6 +336,7 @@ list(APPEND SOURCE_FILES
   DisplayApp/Screens/ScreenList.cpp
   DisplayApp/Screens/Label.cpp
   DisplayApp/Screens/FirmwareUpdate.cpp
+  DisplayApp/Screens/Music.cpp
   main.cpp
   drivers/St7789.cpp
   drivers/SpiNorFlash.cpp
@@ -356,6 +357,7 @@ list(APPEND SOURCE_FILES
   Components/Ble/DfuService.cpp
   Components/Ble/CurrentTimeService.cpp
   Components/Ble/AlertNotificationService.cpp
+  Components/Ble/MusicService.cpp
   drivers/Cst816s.cpp
   FreeRTOS/port.c
   FreeRTOS/port_cmsis_systick.c
diff --git a/src/Components/Ble/MusicService.cpp b/src/Components/Ble/MusicService.cpp
new file mode 100644
index 00000000..5ec76697
--- /dev/null
+++ b/src/Components/Ble/MusicService.cpp
@@ -0,0 +1,130 @@
+#include <SystemTask/SystemTask.h>
+#include "MusicService.h"
+
+int MSCallback(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg) {
+  auto musicService = static_cast<Pinetime::Controllers::MusicService*>(arg);
+  return musicService->OnCommand(conn_handle, attr_handle, ctxt);
+}
+
+Pinetime::Controllers::MusicService::MusicService(Pinetime::System::SystemTask &system) : m_system(system)
+{
+    msUuid.value[11] = msId[0];
+    msUuid.value[12] = msId[1];
+    msEventCharUuid.value[11] = msEventCharId[0];
+    msEventCharUuid.value[12] = msEventCharId[1];
+    msStatusCharUuid.value[11] = msStatusCharId[0];
+    msStatusCharUuid.value[12] = msStatusCharId[1];
+    msTrackCharUuid.value[11] = msTrackCharId[0];
+    msTrackCharUuid.value[12] = msTrackCharId[1];
+    msArtistCharUuid.value[11] = msArtistCharId[0];
+    msArtistCharUuid.value[12] = msArtistCharId[1];
+    msAlbumCharUuid.value[11] = msAlbumCharId[0];
+    msAlbumCharUuid.value[12] = msAlbumCharId[1];
+
+    characteristicDefinition[0] = { .uuid = (ble_uuid_t*)(&msEventCharUuid),
+                                    .access_cb = MSCallback,
+                                    .arg = this,
+                                    .flags =  BLE_GATT_CHR_F_NOTIFY,
+                                    .val_handle = &m_eventHandle
+    };
+    characteristicDefinition[1] = { .uuid = (ble_uuid_t*)(&msStatusCharUuid),
+                                    .access_cb = MSCallback,
+                                    .arg = this,
+                                    .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ
+    };
+    characteristicDefinition[2] = { .uuid = (ble_uuid_t*)(&msTrackCharUuid),
+                                    .access_cb = MSCallback,
+                                    .arg = this,
+                                    .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ
+    };
+    characteristicDefinition[3] = { .uuid = (ble_uuid_t*)(&msArtistCharUuid),
+                                    .access_cb = MSCallback,
+                                    .arg = this,
+                                    .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ
+    };
+    characteristicDefinition[4] = { .uuid = (ble_uuid_t*)(&msAlbumCharUuid),
+                                    .access_cb = MSCallback,
+                                    .arg = this,
+                                    .flags = BLE_GATT_CHR_F_WRITE | BLE_GATT_CHR_F_READ
+    };
+    characteristicDefinition[5] = {0};
+
+    serviceDefinition[0] = {
+                        .type = BLE_GATT_SVC_TYPE_PRIMARY,
+                        .uuid = (ble_uuid_t *) &msUuid,
+                        .characteristics = characteristicDefinition
+    };
+    serviceDefinition[1] = {0};
+
+    m_artist = "Waiting for";
+    m_album = "";
+    m_track = "track information...";
+}
+
+void Pinetime::Controllers::MusicService::Init()
+{
+  int res = 0;
+  res = ble_gatts_count_cfg(serviceDefinition);
+  ASSERT(res == 0);
+
+  res = ble_gatts_add_svcs(serviceDefinition);
+  ASSERT(res == 0);
+}
+
+int Pinetime::Controllers::MusicService::OnCommand(uint16_t conn_handle, uint16_t attr_handle,
+                                                    struct ble_gatt_access_ctxt *ctxt) {
+
+  if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
+        size_t notifSize = OS_MBUF_PKTLEN(ctxt->om);
+        uint8_t data[notifSize + 1];
+        data[notifSize] = '\0';
+        os_mbuf_copydata(ctxt->om, 0, notifSize, data);
+        char *s = (char *) &data[0];
+        NRF_LOG_INFO("DATA : %s", s);
+        if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msArtistCharUuid) == 0) {
+            m_artist = s;
+        } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msTrackCharUuid) == 0) {
+            m_track = s;
+        } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msAlbumCharUuid) == 0) {
+            m_album = s;
+        } else if (ble_uuid_cmp(ctxt->chr->uuid, (ble_uuid_t *)&msStatusCharUuid) == 0) {
+            m_status = s[0];
+        }
+  }
+  return 0;
+}
+
+std::string Pinetime::Controllers::MusicService::album()
+{
+    return m_album;
+}
+
+std::string Pinetime::Controllers::MusicService::artist()
+{
+    return m_artist;
+}
+
+std::string Pinetime::Controllers::MusicService::track()
+{
+    return m_track;
+}
+
+unsigned char Pinetime::Controllers::MusicService::status()
+{
+    return m_status;
+}
+
+void Pinetime::Controllers::MusicService::event(char event)
+{
+    auto *om = ble_hs_mbuf_from_flat(&event, 1);
+    int ret;
+
+    uint16_t connectionHandle = m_system.nimble().connHandle();
+
+    if (connectionHandle == 0 || connectionHandle == BLE_HS_CONN_HANDLE_NONE) {
+        return;
+    }
+
+    ret = ble_gattc_notify_custom(connectionHandle, m_eventHandle, om);
+}
+
diff --git a/src/Components/Ble/MusicService.h b/src/Components/Ble/MusicService.h
new file mode 100644
index 00000000..ab6db572
--- /dev/null
+++ b/src/Components/Ble/MusicService.h
@@ -0,0 +1,92 @@
+#pragma once
+
+#include <cstdint>
+#include <array>
+#include <host/ble_gap.h>
+#include <host/ble_uuid.h>
+#include <string>
+
+//c7e50000-78fc-48fe-8e23-43b37a1942d0
+#define MUSIC_SERVICE_UUID_BASE {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x00, 0x00, 0xe5, 0xc7}
+
+namespace Pinetime {
+  namespace System {
+    class SystemTask;
+  }
+  namespace Controllers {
+
+    class MusicService {
+      public:
+        MusicService(Pinetime::System::SystemTask &system);
+        void Init();
+        int OnCommand(uint16_t conn_handle, uint16_t attr_handle,
+                                    struct ble_gatt_access_ctxt *ctxt);
+
+        std::string artist();
+        std::string track();
+        std::string album();
+        unsigned char status();
+
+        void event(char event);
+
+        static const char EVENT_MUSIC_OPEN = 0xe0;
+        static const char EVENT_MUSIC_PLAY = 0x00;
+        static const char EVENT_MUSIC_PAUSE = 0x01;
+        static const char EVENT_MUSIC_NEXT = 0x03;
+        static const char EVENT_MUSIC_PREV = 0x04;
+        static const char EVENT_MUSIC_VOLUP = 0x05;
+        static const char EVENT_MUSIC_VOLDOWN = 0x06;
+        static const char STATUS_MUSIC_PAUSED = 0x00;
+        static const char STATUS_MUSIC_PLAYING = 0x01;
+
+      private:
+        static constexpr uint8_t msId[2] = {0x00, 0x01};
+        static constexpr uint8_t msEventCharId[2] = {0x00, 0x02};
+        static constexpr uint8_t msStatusCharId[2] = {0x00, 0x03};
+        static constexpr uint8_t msArtistCharId[2] = {0x00, 0x04};
+        static constexpr uint8_t msTrackCharId[2] = {0x00, 0x05};
+        static constexpr uint8_t msAlbumCharId[2] = {0x00, 0x06};
+
+        ble_uuid128_t msUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+
+        ble_uuid128_t msEventCharUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+        ble_uuid128_t msStatusCharUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+        ble_uuid128_t msArtistCharUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+        ble_uuid128_t msTrackCharUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+        ble_uuid128_t msAlbumCharUuid {
+                .u = { .type = BLE_UUID_TYPE_128 },
+                .value = MUSIC_SERVICE_UUID_BASE
+        };
+
+        struct ble_gatt_chr_def characteristicDefinition[6];
+        struct ble_gatt_svc_def serviceDefinition[2];
+
+        uint16_t m_eventHandle;
+
+        std::string m_artist;
+        std::string m_album;
+        std::string m_track;
+
+        unsigned char m_status;
+
+        Pinetime::System::SystemTask& m_system;
+
+    };
+  }
+}
+
diff --git a/src/Components/Ble/NimbleController.cpp b/src/Components/Ble/NimbleController.cpp
index 561dbce4..d7bbd8be 100644
--- a/src/Components/Ble/NimbleController.cpp
+++ b/src/Components/Ble/NimbleController.cpp
@@ -6,6 +6,7 @@
 #include <hal/nrf_rtc.h>
 
 #include "NimbleController.h"
+#include "MusicService.h"
 #include <services/gatt/ble_svc_gatt.h>
 #include <services/gap/ble_svc_gap.h>
 #include <host/util/util.h>
@@ -35,7 +36,8 @@ NimbleController::NimbleController(Pinetime::System::SystemTask& systemTask,
         currentTimeClient{dateTimeController},
         anService{systemTask, notificationManager},
         alertNotificationClient{systemTask, notificationManager},
-        currentTimeService{dateTimeController} {
+        currentTimeService{dateTimeController},
+        musicService{systemTask} {
 
 }
 
@@ -80,6 +82,7 @@ void NimbleController::Init() {
   deviceInformationService.Init();
   currentTimeClient.Init();
   currentTimeService.Init();
+  musicService.Init();
 
   anService.Init();
 
@@ -326,5 +329,7 @@ void NimbleController::StartDiscovery() {
 }
 
 
-
+uint16_t NimbleController::connHandle() {
+    return connectionHandle;
+}
 
diff --git a/src/Components/Ble/NimbleController.h b/src/Components/Ble/NimbleController.h
index cf50d78d..dff93c87 100644
--- a/src/Components/Ble/NimbleController.h
+++ b/src/Components/Ble/NimbleController.h
@@ -7,6 +7,7 @@
 #include "CurrentTimeClient.h"
 #include "DfuService.h"
 #include "CurrentTimeService.h"
+#include "MusicService.h"
 #include <host/ble_gap.h>
 
 namespace Pinetime {
@@ -15,6 +16,7 @@ namespace Pinetime {
   }
   namespace Controllers {
     class DateTime;
+
     class NimbleController {
 
       public:
@@ -35,6 +37,11 @@ namespace Pinetime {
                                                   uint16_t characteristicValueHandle, const ble_gatt_dsc *descriptor);
 
         void StartDiscovery();
+
+        Pinetime::Controllers::MusicService& music() {return musicService;};
+
+        uint16_t connHandle();
+
       private:
         static constexpr char* deviceName = "Pinetime-JF";
         Pinetime::System::SystemTask& systemTask;
@@ -49,9 +56,10 @@ namespace Pinetime {
         AlertNotificationService anService;
         AlertNotificationClient alertNotificationClient;
         CurrentTimeService currentTimeService;
+        MusicService musicService;
 
         uint8_t addrType; // 1 = Random, 0 = PUBLIC
-        uint16_t connectionHandle;
+        uint16_t connectionHandle = 0;
 
         ble_uuid128_t dfuServiceUuid {
                 .u { .type = BLE_UUID_TYPE_128},
diff --git a/src/DisplayApp/DisplayApp.cpp b/src/DisplayApp/DisplayApp.cpp
index 8e35ef55..46a96385 100644
--- a/src/DisplayApp/DisplayApp.cpp
+++ b/src/DisplayApp/DisplayApp.cpp
@@ -15,6 +15,7 @@
 #include <DisplayApp/Screens/Gauge.h>
 #include <DisplayApp/Screens/Brightness.h>
 #include <DisplayApp/Screens/ScreenList.h>
+#include <DisplayApp/Screens/Music.h>
 #include <Components/Ble/NotificationManager.h>
 #include <DisplayApp/Screens/FirmwareUpdate.h>
 #include "../SystemTask/SystemTask.h"
@@ -189,6 +190,7 @@ void DisplayApp::RunningState() {
       case Apps::Meter: currentScreen.reset(new Screens::Meter(this)); break;
       case Apps::Gauge: currentScreen.reset(new Screens::Gauge(this)); break;
       case Apps::Brightness : currentScreen.reset(new Screens::Brightness(this, brightnessController)); break;
+      case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); break;
     }
     nextApp = Apps::None;
   }
diff --git a/src/DisplayApp/DisplayApp.h b/src/DisplayApp/DisplayApp.h
index 36f9315b..23f04937 100644
--- a/src/DisplayApp/DisplayApp.h
+++ b/src/DisplayApp/DisplayApp.h
@@ -42,7 +42,7 @@ namespace Pinetime {
         void Start();
         void PushMessage(Messages msg);
 
-        enum class Apps {None, Launcher, Clock, SysInfo, Meter, Gauge, Brightness};
+        enum class Apps {None, Launcher, Clock, SysInfo, Meter, Gauge, Brightness, Music};
         void StartApp(Apps app);
 
         void SetFullRefresh(FullRefreshDirections direction);
diff --git a/src/DisplayApp/Screens/Gauge.cpp b/src/DisplayApp/Screens/Gauge.cpp
index 4c4cccd9..fd905231 100644
--- a/src/DisplayApp/Screens/Gauge.cpp
+++ b/src/DisplayApp/Screens/Gauge.cpp
@@ -19,6 +19,7 @@ Gauge::Gauge(Pinetime::Applications::DisplayApp *app) : Screen(app) {
   style.text.color = LV_COLOR_WHITE;
   style.line.color = LV_COLOR_RED;                  /*Line color after the critical value*/
 
+
   /*Describe the color for the needles*/
 
   needle_colors[0] = LV_COLOR_ORANGE;
diff --git a/src/DisplayApp/Screens/Music.cpp b/src/DisplayApp/Screens/Music.cpp
new file mode 100644
index 00000000..9b7d198b
--- /dev/null
+++ b/src/DisplayApp/Screens/Music.cpp
@@ -0,0 +1,125 @@
+#include <libs/lvgl/lvgl.h>
+#include "Music.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)
+{
+  Music* screen = static_cast<Music *>(obj->user_data);
+  screen->OnObjectEvent(obj, event);
+}
+
+Music::Music(Pinetime::Applications::DisplayApp *app, Pinetime::Controllers::MusicService &music) : Screen(app), musicService(music) {
+    lv_obj_t * label;
+
+    btnVolDown = lv_btn_create(lv_scr_act(), NULL);
+    btnVolDown->user_data = this;
+    lv_obj_set_event_cb(btnVolDown, event_handler);
+    lv_obj_align(btnVolDown, NULL, LV_ALIGN_IN_TOP_LEFT, 10, 10);
+    label = lv_label_create(btnVolDown, NULL);
+    lv_label_set_text(label, "v-");
+
+    btnVolUp = lv_btn_create(lv_scr_act(), NULL);
+    btnVolUp->user_data = this;
+    lv_obj_set_event_cb(btnVolUp, event_handler);
+    lv_obj_align(btnVolUp, NULL, LV_ALIGN_IN_TOP_RIGHT, -10, 10);
+    label = lv_label_create(btnVolUp, NULL);
+    lv_label_set_text(label, "v+");
+
+    btnPrev = lv_btn_create(lv_scr_act(), NULL);
+    btnPrev->user_data = this;
+    lv_obj_set_event_cb(btnPrev, event_handler);
+    lv_obj_set_size(btnPrev, LV_HOR_RES / 4, LV_VER_RES / 4);
+    lv_obj_align(btnPrev, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 10,-10);
+    label = lv_label_create(btnPrev, NULL);
+    lv_label_set_text(label, "<<");
+
+    btnPlayPause = lv_btn_create(lv_scr_act(), NULL);
+    btnPlayPause->user_data = this;
+    lv_obj_set_event_cb(btnPlayPause, event_handler);
+    lv_obj_set_size(btnPlayPause, LV_HOR_RES / 4, LV_VER_RES / 4);
+    lv_obj_align(btnPlayPause, NULL, LV_ALIGN_IN_BOTTOM_MID, 0,-10);
+    txtPlayPause = lv_label_create(btnPlayPause, NULL);
+    lv_label_set_text(txtPlayPause, ">");
+
+    btnNext = lv_btn_create(lv_scr_act(), NULL);
+    btnNext->user_data = this;
+    lv_obj_set_event_cb(btnNext, event_handler);
+    lv_obj_set_size(btnNext, LV_HOR_RES / 4, LV_VER_RES / 4);
+    lv_obj_align(btnNext, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, -10,-10);
+    label = lv_label_create(btnNext, NULL);
+    lv_label_set_text(label, ">>");
+
+    txtArtist = lv_label_create(lv_scr_act(), NULL);
+    lv_label_set_long_mode(txtArtist, LV_LABEL_LONG_SROLL);
+    lv_obj_align(txtArtist, NULL, LV_ALIGN_IN_LEFT_MID, 0,-20);
+    lv_label_set_text(txtArtist, "Artist Name");
+    lv_label_set_align(txtArtist, LV_LABEL_ALIGN_CENTER);
+    lv_obj_set_width(txtArtist, LV_HOR_RES);
+
+    txtTrack = lv_label_create(lv_scr_act(), NULL);
+    lv_label_set_long_mode(txtTrack, LV_LABEL_LONG_DOT);
+    lv_obj_align(txtTrack, NULL, LV_ALIGN_IN_LEFT_MID, 0,20);
+    lv_label_set_text(txtTrack, "This is a very long track name");
+    lv_label_set_align(txtTrack, LV_LABEL_ALIGN_CENTER);
+    lv_obj_set_width(txtTrack, LV_HOR_RES);
+
+    musicService.event(Controllers::MusicService::EVENT_MUSIC_OPEN);
+}
+
+Music::~Music() {
+  lv_obj_clean(lv_scr_act());
+}
+
+bool Music::OnButtonPushed() {
+  running = false;
+  return true;
+}
+
+bool Music::Refresh() {
+
+    if (m_artist != musicService.artist()) {
+        m_artist = musicService.artist();
+        lv_label_set_text(txtArtist, m_artist.data());
+    }
+    if (m_track != musicService.track()) {
+        m_track = musicService.track();
+        lv_label_set_text(txtTrack, m_track.data());
+    }
+    if (m_album != musicService.album()) {
+        m_album = musicService.album();
+    }
+    if (m_status != musicService.status()) {
+        m_status = musicService.status();
+    }
+    if (m_status == Pinetime::Controllers::MusicService::STATUS_MUSIC_PLAYING) {
+        lv_label_set_text(txtPlayPause, "||");
+    } else {
+        lv_label_set_text(txtPlayPause, ">");
+    }
+
+  return running;
+}
+
+void Music::OnObjectEvent(lv_obj_t* obj, lv_event_t event)
+{
+    if (event == LV_EVENT_CLICKED) {
+        if (obj == btnVolDown) {
+            musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLDOWN);
+        } else if (obj == btnVolUp) {
+            musicService.event(Controllers::MusicService::EVENT_MUSIC_VOLUP);
+        } else if (obj == btnPrev) {
+            musicService.event(Controllers::MusicService::EVENT_MUSIC_PREV);
+        } else if (obj == btnPlayPause) {
+            if (m_status == Pinetime::Controllers::MusicService::STATUS_MUSIC_PLAYING) {
+                musicService.event(Controllers::MusicService::EVENT_MUSIC_PAUSE);
+            } else {
+                musicService.event(Controllers::MusicService::EVENT_MUSIC_PLAY);
+            }
+        } else if (obj == btnNext) {
+            musicService.event(Controllers::MusicService::EVENT_MUSIC_NEXT);
+        }
+    }
+}
diff --git a/src/DisplayApp/Screens/Music.h b/src/DisplayApp/Screens/Music.h
new file mode 100644
index 00000000..95cac0f0
--- /dev/null
+++ b/src/DisplayApp/Screens/Music.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstdint>
+#include <chrono>
+#include <Components/Gfx/Gfx.h>
+#include "Screen.h"
+#include <bits/unique_ptr.h>
+#include <libs/lvgl/src/lv_core/lv_style.h>
+#include <libs/lvgl/src/lv_core/lv_obj.h>
+#include <Components/Battery/BatteryController.h>
+#include <Components/Ble/BleController.h>
+#include "../../Version.h"
+#include <Components/Ble/MusicService.h>
+#include <string>
+
+namespace Pinetime {
+  namespace Applications {
+    namespace Screens {
+
+      class Music : public Screen{
+        public:
+          Music(DisplayApp* app, Pinetime::Controllers::MusicService &music);
+          ~Music() override;
+
+          bool Refresh() override;
+          bool OnButtonPushed() override;
+
+          void OnObjectEvent(lv_obj_t* obj, lv_event_t event);
+
+        private:
+          lv_obj_t * btnPrev;
+          lv_obj_t * btnPlayPause;
+          lv_obj_t * btnNext;
+          lv_obj_t * btnVolDown;
+          lv_obj_t * btnVolUp;
+          lv_obj_t * txtArtist;
+          lv_obj_t * txtTrack;
+          lv_obj_t * txtPlayPause;
+
+          bool running = true;
+          Pinetime::Controllers::MusicService &musicService;
+          std::string m_artist;
+          std::string m_album;
+          std::string m_track;
+          unsigned char m_status;
+      };
+    }
+  }
+}
diff --git a/src/DisplayApp/Screens/Tile.cpp b/src/DisplayApp/Screens/Tile.cpp
index 61e3c01d..c3a9d380 100644
--- a/src/DisplayApp/Screens/Tile.cpp
+++ b/src/DisplayApp/Screens/Tile.cpp
@@ -95,7 +95,7 @@ void Tile::StartMeterApp() {
 }
 
 void Tile::StartGaugeApp() {
-  app->StartApp(DisplayApp::Apps::Gauge);
+  app->StartApp(DisplayApp::Apps::Music);
   running = false;
 }
 
diff --git a/src/SystemTask/SystemTask.cpp b/src/SystemTask/SystemTask.cpp
index 8f565860..9f57f6f6 100644
--- a/src/SystemTask/SystemTask.cpp
+++ b/src/SystemTask/SystemTask.cpp
@@ -12,6 +12,7 @@
 #include <host/util/util.h>
 #include <drivers/InternalFlash.h>
 #include "../main.h"
+#include "Components/Ble/NimbleController.h"
 
 using namespace Pinetime::System;
 
diff --git a/src/SystemTask/SystemTask.h b/src/SystemTask/SystemTask.h
index 8fa7e7d1..3e53baed 100644
--- a/src/SystemTask/SystemTask.h
+++ b/src/SystemTask/SystemTask.h
@@ -8,9 +8,10 @@
 #include <Components/Battery/BatteryController.h>
 #include <DisplayApp/DisplayApp.h>
 #include <drivers/Watchdog.h>
-#include <Components/Ble/NimbleController.h>
 #include <drivers/SpiNorFlash.h>
 #include "SystemMonitor.h"
+#include "Components/Ble/NimbleController.h"
+#include "timers.h"
 
 namespace Pinetime {
   namespace System {
@@ -37,6 +38,8 @@ namespace Pinetime {
 
         void OnIdle();
 
+        Pinetime::Controllers::NimbleController& nimble() {return nimbleController;};
+
       private:
         TaskHandle_t taskHandle;
 
@@ -84,4 +87,4 @@ namespace Pinetime {
 #endif
     };
   }
-}
\ No newline at end of file
+}