pinetime/InfiniTime
1
0
Fork 0
Code Activity

replaced all unique_ptr.reset calls with std::make_unique

Browse source
This commit is contained in:
Niall Cooling 2021-03-22 17:56:26 +00:00
parent e5e3fc02b8
commit 8eb947a223
7 changed files with 45 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/displayapp/DisplayApp.cpp
View file

@ -123,7 +123,7 @@ void DisplayApp::Refresh() {
currentScreen.reset(nullptr); currentScreen.reset(nullptr);
lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up); lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up);
onClockApp = false; onClockApp = false;
currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview)); currentScreen = std::make_unique<Screens::Notifications>(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview);
} }
} }
break; break;
@ -161,10 +161,10 @@ void DisplayApp::Refresh() {
// lvgl.SetFullRefresh(components::LittleVgl::FullRefreshDirections::Down); // lvgl.SetFullRefresh(components::LittleVgl::FullRefreshDirections::Down);
// currentScreen.reset(nullptr); // currentScreen.reset(nullptr);
// if(toggle) { // if(toggle) {
// currentScreen.reset(new Screens::Tile(this)); // currentScreen = std::make_unique<Screens::Tile>(this);
// toggle = false; // toggle = false;
// } else { // } else {
// currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController)); // currentScreen = std::make_unique<Screens::Clock>(this, dateTimeController, batteryController, bleController);
// toggle = true; // toggle = true;
// } // }
@ -172,9 +172,13 @@ void DisplayApp::Refresh() {
case Messages::BleFirmwareUpdateStarted: case Messages::BleFirmwareUpdateStarted:
lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down); lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Down);
currentScreen.reset(nullptr); currentScreen.reset(nullptr);
currentScreen.reset(new Screens::FirmwareUpdate(this, bleController)); currentScreen = std::make_unique<Screens::FirmwareUpdate>(this, bleController);
onClockApp = false; onClockApp = false;
break;
case Messages::UpdateDateTime:
// Added to remove warning
// What should happen here?
break; break;
} }
} }
@ -198,23 +202,23 @@ void DisplayApp::RunningState() {
onClockApp = false; onClockApp = false;
switch(nextApp) { switch(nextApp) {
case Apps::None: case Apps::None:
case Apps::Launcher: currentScreen.reset(new Screens::ApplicationList(this, settingsController)); break; case Apps::Launcher: currentScreen = std::make_unique<Screens::ApplicationList>(this, settingsController); break;
case Apps::Clock: case Apps::Clock:
currentScreen.reset(new Screens::Clock(this, dateTimeController, batteryController, bleController, notificationManager, settingsController, heartRateController)); currentScreen = std::make_unique<Screens::Clock>(this, dateTimeController, batteryController, bleController, notificationManager, settingsController, heartRateController);
onClockApp = true; onClockApp = true;
break; break;
case Apps::SysInfo: currentScreen.reset(new Screens::SystemInfo(this, dateTimeController, batteryController, brightnessController, bleController, watchdog)); break; case Apps::SysInfo: currentScreen = std::make_unique<Screens::SystemInfo>(this, dateTimeController, batteryController, brightnessController, bleController, watchdog); break;
case Apps::Meter: currentScreen.reset(new Screens::Meter(this)); break; case Apps::Meter: currentScreen = std::make_unique<Screens::Meter>(this);break;
case Apps::StopWatch: currentScreen.reset(new Screens::StopWatch(this)); break; case Apps::StopWatch: currentScreen = std::make_unique<Screens::StopWatch>(this); break;
case Apps::Twos: currentScreen.reset(new Screens::Twos(this)); break; case Apps::Twos: currentScreen = std::make_unique<Screens::Twos>(this); break;
case Apps::Paint: currentScreen.reset(new Screens::InfiniPaint(this, lvgl)); break; case Apps::Paint: currentScreen = std::make_unique<Screens::InfiniPaint>(this, lvgl); break;
case Apps::Paddle: currentScreen.reset(new Screens::Paddle(this, lvgl)); break; case Apps::Paddle: currentScreen = std::make_unique<Screens::Paddle>(this, lvgl); break;
case Apps::Brightness : currentScreen.reset(new Screens::Brightness(this, brightnessController)); break; case Apps::Brightness : currentScreen = std::make_unique<Screens::Brightness>(this, brightnessController); break;
case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); break; case Apps::Music : currentScreen = std::make_unique<Screens::Music>(this, systemTask.nimble().music()); break;
case Apps::Navigation : currentScreen.reset(new Screens::Navigation(this, systemTask.nimble().navigation())); break; case Apps::Navigation : currentScreen = std::make_unique<Screens::Navigation>(this, systemTask.nimble().navigation()); break;
case Apps::FirmwareValidation: currentScreen.reset(new Screens::FirmwareValidation(this, validator)); break; case Apps::FirmwareValidation: currentScreen = std::make_unique<Screens::FirmwareValidation>(this, validator); break;
case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal)); break; case Apps::Notifications: currentScreen = std::make_unique<Screens::Notifications>(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal); break;
case Apps::HeartRate: currentScreen.reset(new Screens::HeartRate(this, heartRateController)); break; case Apps::HeartRate: currentScreen = std::make_unique<Screens::HeartRate>(this, heartRateController); break;
} }
nextApp = Apps::None; nextApp = Apps::None;
} }

6
src/displayapp/screens/ApplicationList.cpp
View file

@ -56,7 +56,7 @@ std::unique_ptr<Screen> ApplicationList::CreateScreen1() {
}; };
return std::unique_ptr<Screen>(new Screens::Tile(0, app, settingsController, applications)); return std::make_unique<Screens::Tile>(0, app, settingsController, applications);
} }
std::unique_ptr<Screen> ApplicationList::CreateScreen2() { std::unique_ptr<Screen> ApplicationList::CreateScreen2() {
@ -70,7 +70,7 @@ std::unique_ptr<Screen> ApplicationList::CreateScreen2() {
} }
}; };
return std::unique_ptr<Screen>(new Screens::Tile(1, app, settingsController, applications)); return std::make_unique<Screens::Tile>(1, app, settingsController, applications);
} }
std::unique_ptr<Screen> ApplicationList::CreateScreen3() { std::unique_ptr<Screen> ApplicationList::CreateScreen3() {
@ -84,6 +84,6 @@ std::unique_ptr<Screen> ApplicationList::CreateScreen3() {
} }
}; };
return std::unique_ptr<Screen>(new Screens::Tile(2, app, settingsController, applications)); return std::make_unique<Screens::Tile>(2, app, settingsController, applications);
} }

8
src/displayapp/screens/Clock.cpp
View file

@ -64,20 +64,20 @@ bool Clock::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
} }
std::unique_ptr<Screen> Clock::WatchFaceDigitalScreen() { std::unique_ptr<Screen> Clock::WatchFaceDigitalScreen() {
return std::unique_ptr<Screen>(new Screens::WatchFaceDigital(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController, heartRateController)); return std::make_unique<Screens::WatchFaceDigital>(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController, heartRateController);
} }
std::unique_ptr<Screen> Clock::WatchFaceAnalogScreen() { std::unique_ptr<Screen> Clock::WatchFaceAnalogScreen() {
return std::unique_ptr<Screen>(new Screens::WatchFaceAnalog(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController)); return std::make_unique<Screens::WatchFaceAnalog>(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController);
} }
/* /*
// Examples for more watch faces // Examples for more watch faces
std::unique_ptr<Screen> Clock::WatchFaceMinimalScreen() { std::unique_ptr<Screen> Clock::WatchFaceMinimalScreen() {
return std::unique_ptr<Screen>(new Screens::WatchFaceMinimal(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController)); return std::make_unique<Screens::WatchFaceMinimal>(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController);
} }
std::unique_ptr<Screen> Clock::WatchFaceCustomScreen() { std::unique_ptr<Screen> Clock::WatchFaceCustomScreen() {
return std::unique_ptr<Screen>(new Screens::WatchFaceCustom(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController)); return std::make_unique<Screens::WatchFaceCustom>(app, dateTimeController, batteryController, bleController, notificatioManager, settingsController);
} }
*/ */

16
src/displayapp/screens/Notifications.cpp
View file

@ -17,22 +17,22 @@ Notifications::Notifications(DisplayApp *app,
auto notification = notificationManager.GetLastNotification(); auto notification = notificationManager.GetLastNotification();
if(notification.valid) { if(notification.valid) {
currentId = notification.id; currentId = notification.id;
currentItem.reset(new NotificationItem("\nNotification", currentItem = std::make_unique<NotificationItem>("\nNotification",
notification.message.data(), notification.message.data(),
notification.index, notification.index,
notification.category, notification.category,
notificationManager.NbNotifications(), notificationManager.NbNotifications(),
mode, mode,
alertNotificationService)); alertNotificationService);
validDisplay = true; validDisplay = true;
} else { } else {
currentItem.reset(new NotificationItem("\nNotification", currentItem = std::make_unique<NotificationItem>("\nNotification",
"No notification to display", "No notification to display",
0, 0,
notification.category, notification.category,
notificationManager.NbNotifications(), notificationManager.NbNotifications(),
Modes::Preview, Modes::Preview,
alertNotificationService)); alertNotificationService);
} }
if(mode == Modes::Preview) { if(mode == Modes::Preview) {
@ -87,13 +87,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
currentId = previousNotification.id; currentId = previousNotification.id;
currentItem.reset(nullptr); currentItem.reset(nullptr);
app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up); app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
currentItem.reset(new NotificationItem("\nNotification", currentItem = std::make_unique<NotificationItem>("\nNotification",
previousNotification.message.data(), previousNotification.message.data(),
previousNotification.index, previousNotification.index,
previousNotification.category, previousNotification.category,
notificationManager.NbNotifications(), notificationManager.NbNotifications(),
mode, mode,
alertNotificationService)); alertNotificationService);
} }
return true; return true;
case Pinetime::Applications::TouchEvents::SwipeDown: { case Pinetime::Applications::TouchEvents::SwipeDown: {
@ -109,13 +109,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
currentId = nextNotification.id; currentId = nextNotification.id;
currentItem.reset(nullptr); currentItem.reset(nullptr);
app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down); app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
currentItem.reset(new NotificationItem("\nNotification", currentItem = std::make_unique<NotificationItem>("\nNotification",
nextNotification.message.data(), nextNotification.message.data(),
nextNotification.index, nextNotification.index,
nextNotification.category, nextNotification.category,
notificationManager.NbNotifications(), notificationManager.NbNotifications(),
mode, mode,
alertNotificationService)); alertNotificationService);
} }
return true; return true;
case Pinetime::Applications::TouchEvents::LongTap: { case Pinetime::Applications::TouchEvents::LongTap: {

6
src/displayapp/screens/SystemInfo.cpp
View file

@ -104,14 +104,14 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen1() {
uptimeDays, uptimeHours, uptimeMinutes, uptimeSeconds, uptimeDays, uptimeHours, uptimeMinutes, uptimeSeconds,
batteryPercent, brightness, resetReason); batteryPercent, brightness, resetReason);
return std::unique_ptr<Screen>(new Screens::Label(app, t1)); return std::make_unique<Screens::Label>(app, t1);
} }
std::unique_ptr<Screen> SystemInfo::CreateScreen2() { std::unique_ptr<Screen> SystemInfo::CreateScreen2() {
auto& bleAddr = bleController.Address(); auto& bleAddr = bleController.Address();
sprintf(t2, "BLE MAC: \n %02x:%02x:%02x:%02x:%02x:%02x", sprintf(t2, "BLE MAC: \n %02x:%02x:%02x:%02x:%02x:%02x",
bleAddr[5], bleAddr[4], bleAddr[3], bleAddr[2], bleAddr[1], bleAddr[0]); bleAddr[5], bleAddr[4], bleAddr[3], bleAddr[2], bleAddr[1], bleAddr[0]);
return std::unique_ptr<Screen>(new Screens::Label(app, t2)); return std::make_unique<Screens::Label>(app, t2);
} }
std::unique_ptr<Screen> SystemInfo::CreateScreen3() { std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
@ -123,5 +123,5 @@ std::unique_ptr<Screen> SystemInfo::CreateScreen3() {
"Source code:\n" "Source code:\n"
"https://github.com/\n" "https://github.com/\n"
" JF002/InfiniTime"); " JF002/InfiniTime");
return std::unique_ptr<Screen>(new Screens::Label(app, t3)); return std::make_unique<Screens::Label>(app, t3);
} }

6
src/main.cpp
View file

@ -49,6 +49,8 @@ Pinetime::Logging::NrfLogger logger;
Pinetime::Logging::DummyLogger logger; Pinetime::Logging::DummyLogger logger;
#endif #endif
#include <memory>
static constexpr uint8_t pinSpiSck = 2; static constexpr uint8_t pinSpiSck = 2;
static constexpr uint8_t pinSpiMosi = 3; static constexpr uint8_t pinSpiMosi = 3;
static constexpr uint8_t pinSpiMiso = 4; static constexpr uint8_t pinSpiMiso = 4;
@ -254,8 +256,8 @@ int main(void) {
debounceTimer = xTimerCreate ("debounceTimer", 200, pdFALSE, (void *) 0, DebounceTimerCallback); debounceTimer = xTimerCreate ("debounceTimer", 200, pdFALSE, (void *) 0, DebounceTimerCallback);
systemTask.reset(new Pinetime::System::SystemTask(spi, lcd, spiNorFlash, twiMaster, touchPanel, lvgl, batteryController, bleController, systemTask = std::make_unique<Pinetime::System::SystemTask>(spi, lcd, spiNorFlash, twiMaster, touchPanel, lvgl, batteryController, bleController,
dateTimeController, motorController, heartRateSensor, settingsController)); dateTimeController, motorController, heartRateSensor, settingsController);
systemTask->Start(); systemTask->Start();
nimble_port_init(); nimble_port_init();

2
src/systemtask/SystemTask.cpp
View file

@ -98,7 +98,7 @@ void SystemTask::Work() {
heartRateSensor.Init(); heartRateSensor.Init();
heartRateSensor.Disable(); heartRateSensor.Disable();
heartRateApp.reset(new Pinetime::Applications::HeartRateTask(heartRateSensor, heartRateController)); heartRateApp = std::make_unique<Pinetime::Applications::HeartRateTask>(heartRateSensor, heartRateController);
heartRateApp->Start(); heartRateApp->Start();