will/InfiniTime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Handle call notification the same way than other notifications.

Browse Source 
Display the call notifications in the Notification app, with buttons to accept/reject the call.
This commit is contained in:
Jean-François Milants 2021-01-24 17:22:39 +01:00
parent 6d76dbc911
commit 219bafb01a
13 changed files with 198 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@ -426,7 +426,6 @@ list(APPEND SOURCE_FILES
displayapp/screens/InfiniPaint.cpp
displayapp/screens/Paddle.cpp
displayapp/screens/DropDownDemo.cpp
displayapp/screens/Modal.cpp
displayapp/screens/BatteryIcon.cpp
displayapp/screens/BleIcon.cpp
displayapp/screens/NotificationIcon.cpp
@ -520,7 +519,6 @@ set(INCLUDE_FILES
displayapp/screens/InfiniPaint.h
displayapp/screens/Paddle.h
displayapp/screens/DropDownDemo.h
displayapp/screens/Modal.h
displayapp/screens/BatteryIcon.h
displayapp/screens/BleIcon.h
displayapp/screens/NotificationIcon.h

34
src/components/ble/AlertNotificationService.cpp
View File

@ -69,30 +69,46 @@ int AlertNotificationService::OnAlert(uint16_t conn_handle, uint16_t attr_handle
const auto dbgPacketLen = OS_MBUF_PKTLEN(ctxt->om);
size_t bufferSize = std::min(dbgPacketLen + stringTerminatorSize, maxBufferSize);
auto messageSize = std::min(maxMessageSize, (bufferSize-headerSize));
uint8_t* category = new uint8_t[1];
Categories category;
NotificationManager::Notification notif;
os_mbuf_copydata(ctxt->om, headerSize, messageSize-1, notif.message.data());
os_mbuf_copydata(ctxt->om, 0, 1, category);
os_mbuf_copydata(ctxt->om, 0, 1, &category);
notif.message[messageSize-1] = '\0';
notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
Pinetime::System::SystemTask::Messages event = Pinetime::System::SystemTask::Messages::OnNewNotification;
switch(*category) {
case (uint8_t) ANS_TYPE_NOTIFICATION_CALL:
// TODO convert all ANS categories to NotificationController categories
switch(category) {
case Categories::Call:
notif.category = Pinetime::Controllers::NotificationManager::Categories::IncomingCall;
event = Pinetime::System::SystemTask::Messages::OnNewCall;
break;
default:
notif.category = Pinetime::Controllers::NotificationManager::Categories::SimpleAlert;
break;
}
auto event = Pinetime::System::SystemTask::Messages::OnNewNotification;
notificationManager.Push(std::move(notif));
systemTask.PushMessage(event);
}
return 0;
}
void AlertNotificationService::event(char event) {
auto *om = ble_hs_mbuf_from_flat(&event, 1);
void AlertNotificationService::AcceptIncomingCall() {
auto response = IncomingCallResponses::Answer;
auto *om = ble_hs_mbuf_from_flat(&response, 1);
uint16_t connectionHandle = systemTask.nimble().connHandle();
if (connectionHandle == 0 || connectionHandle == BLE_HS_CONN_HANDLE_NONE) {
return;
}
ble_gattc_notify_custom(connectionHandle, eventHandle, om);
}
void AlertNotificationService::RejectIncomingCall() {
auto response = IncomingCallResponses::Reject;
auto *om = ble_hs_mbuf_from_flat(&response, 1);
uint16_t connectionHandle = systemTask.nimble().connHandle();

38
src/components/ble/AlertNotificationService.h
View File

@ -7,8 +7,8 @@
#undef max
#undef min
//00020000-78fc-48fe-8e23-433b3a1942d0
#define NOTIFICATION_EVENT_SERVICE_UUID_BASE {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x00, 0x00, 0x02, 0x00}
//00020001-78fc-48fe-8e23-433b3a1942d0
#define NOTIFICATION_EVENT_SERVICE_UUID_BASE {0xd0, 0x42, 0x19, 0x3a, 0x3b, 0x43, 0x23, 0x8e, 0xfe, 0x48, 0xfc, 0x78, 0x01, 0x00, 0x02, 0x00}
namespace Pinetime {
@ -27,24 +27,28 @@ namespace Pinetime {
int OnAlert(uint16_t conn_handle, uint16_t attr_handle,
struct ble_gatt_access_ctxt *ctxt);
void event(char event);
static const char EVENT_HANG_UP_CALL = 0x00;
static const char EVENT_ANSWER_CALL = 0x01;
void AcceptIncomingCall();
void RejectIncomingCall();
enum class IncomingCallResponses : uint8_t {
Reject = 0x00,
Answer = 0x01
};
private:
static const char ANS_TYPE_SIMPLE_ALERT = 0x00;
static const char ANS_TYPE_EMAIL = 0x01;
static const char ANS_TYPE_NEWS = 0x02;
static const char ANS_TYPE_NOTIFICATION_CALL = 0x03;
static const char ANS_TYPE_MISSED_CALL = 0x04;
static const char ANS_TYPE_SMS_MMS = 0x05;
static const char ANS_TYPE_VOICE_MAIL = 0x06;
static const char ANS_TYPE_SCHEDULE = 0x07;
static const char ANS_TYPE_HIGH_PRIORITIZED_ALERT = 0x08;
static const char ANS_TYPE_INSTANT_MESSAGE = 0x09;
static const char ANS_TYPE_ALL_ALERTS = 0xff;
enum class Categories : uint8_t {
SimpleAlert = 0x00,
Email = 0x01,
News = 0x02,
Call = 0x03,
MissedCall = 0x04,
MmsSms = 0x05,
VoiceMail = 0x06,
Schedule = 0x07,
HighPrioritizedAlert = 0x08,
InstantMessage = 0x09,
All = 0xff
};
static constexpr uint16_t ansId {0x1811};
static constexpr uint16_t ansCharId {0x2a46};

11
src/displayapp/DisplayApp.cpp
View File

@ -46,7 +46,6 @@ DisplayApp::DisplayApp(Drivers::St7789 &lcd, Components::LittleVgl &lvgl, Driver
heartRateController{heartRateController} {
msgQueue = xQueueCreate(queueSize, itemSize);
onClockApp = true;
modal.reset(new Screens::Modal(this));
}
void DisplayApp::Start() {
@ -110,9 +109,6 @@ void DisplayApp::Refresh() {
brightnessController.Restore();
state = States::Running;
break;
case Messages::UpdateDateTime:
// modal->Show();
break;
case Messages::UpdateBleConnection:
// clockScreen.SetBleConnectionState(bleController.IsConnected() ? Screens::Clock::BleConnectionStates::Connected : Screens::Clock::BleConnectionStates::NotConnected);
break;
@ -124,13 +120,10 @@ void DisplayApp::Refresh() {
currentScreen.reset(nullptr);
lvgl.SetFullRefresh(Components::LittleVgl::FullRefreshDirections::Up);
onClockApp = false;
currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Preview));
currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Preview));
}
}
break;
case Messages::NewCall:
modal->NewNotification(notificationManager, &systemTask.nimble().alertService());
break;
case Messages::TouchEvent: {
if (state != States::Running) break;
auto gesture = OnTouchEvent();
@ -218,7 +211,7 @@ void DisplayApp::RunningState() {
case Apps::Music : currentScreen.reset(new Screens::Music(this, systemTask.nimble().music())); break;
case Apps::Navigation : currentScreen.reset(new Screens::Navigation(this, systemTask.nimble().navigation())); break;
case Apps::FirmwareValidation: currentScreen.reset(new Screens::FirmwareValidation(this, validator)); break;
case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, Screens::Notifications::Modes::Normal)); break;
case Apps::Notifications: currentScreen.reset(new Screens::Notifications(this, notificationManager, systemTask.nimble().alertService(), Screens::Notifications::Modes::Normal)); break;
case Apps::HeartRate: currentScreen.reset(new Screens::HeartRate(this, heartRateController)); break;
}
nextApp = Apps::None;

3
src/displayapp/DisplayApp.h
View File

@ -34,7 +34,7 @@ namespace Pinetime {
public:
enum class States {Idle, Running};
enum class Messages : uint8_t {GoToSleep, GoToRunning, UpdateDateTime, UpdateBleConnection, UpdateBatteryLevel, TouchEvent, ButtonPushed,
NewNotification, NewCall, BleFirmwareUpdateStarted };
NewNotification, BleFirmwareUpdateStarted };
enum class FullRefreshDirections { None, Up, Down };
enum class TouchModes { Gestures, Polling };
@ -85,7 +85,6 @@ namespace Pinetime {
Apps nextApp = Apps::None;
bool onClockApp = false; // TODO find a better way to know that we should handle gestures and button differently for the Clock app.
Controllers::BrightnessController brightnessController;
std::unique_ptr<Screens::Modal> modal;
Pinetime::Controllers::NotificationManager& notificationManager;
Pinetime::Controllers::FirmwareValidator validator;
TouchModes touchMode = TouchModes::Gestures;

4
src/displayapp/screens/Navigation.h
View File

@ -145,7 +145,7 @@ namespace Pinetime {
const lv_img_dsc_t* iconForName(std::string icon);
std::array<std::pair<std::string, const lv_img_dsc_t*>, 89 > m_iconMap = { {
std::array<std::pair<std::string, const lv_img_dsc_t*>, 89 > m_iconMap;/* = { {
{"arrive-left", &arrive_left},
{"arrive-right", &arrive_right},
{"arrive-straight", &arrive_straight},
@ -231,7 +231,7 @@ namespace Pinetime {
{"turn-slight-right", &turn_slight_right},
{"turn-straight", &turn_straight},
{"updown", &updown},
{"uturn", &uturn} } };
{"uturn", &uturn} } };*/
};
}
}

115
src/displayapp/screens/Notifications.cpp
View File

@ -1,18 +1,34 @@
#include "Notifications.h"
#include <displayapp/DisplayApp.h>
#include "components/ble/MusicService.h"
using namespace Pinetime::Applications::Screens;
Notifications::Notifications(DisplayApp *app, Pinetime::Controllers::NotificationManager &notificationManager, Modes mode) :
Screen(app), notificationManager{notificationManager}, mode{mode} {
Notifications::Notifications(DisplayApp *app,
Pinetime::Controllers::NotificationManager &notificationManager,
Pinetime::Controllers::AlertNotificationService& alertNotificationService,
Modes mode) :
Screen(app), notificationManager{notificationManager}, alertNotificationService{alertNotificationService}, mode{mode} {
notificationManager.ClearNewNotificationFlag();
auto notification = notificationManager.GetLastNotification();
if(notification.valid) {
currentId = notification.id;
currentItem.reset(new NotificationItem("\nNotification", notification.message.data(), notification.index, notificationManager.NbNotifications(), mode));
currentItem.reset(new NotificationItem("\nNotification",
notification.message.data(),
notification.index,
notification.category,
notificationManager.NbNotifications(),
mode,
alertNotificationService));
validDisplay = true;
} else {
currentItem.reset(new NotificationItem("\nNotification", "No notification to display", 0, notificationManager.NbNotifications(), Modes::Preview));
currentItem.reset(new NotificationItem("\nNotification",
"No notification to display",
0,
notification.category,
notificationManager.NbNotifications(),
Modes::Preview,
alertNotificationService));
}
if(mode == Modes::Preview) {
@ -69,7 +85,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
currentId = previousNotification.id;
currentItem.reset(nullptr);
app->SetFullRefresh(DisplayApp::FullRefreshDirections::Up);
currentItem.reset(new NotificationItem("\nNotification", previousNotification.message.data(), previousNotification.index, notificationManager.NbNotifications(), mode));
currentItem.reset(new NotificationItem("\nNotification",
previousNotification.message.data(),
previousNotification.index,
previousNotification.category,
notificationManager.NbNotifications(),
mode,
alertNotificationService));
}
return true;
case Pinetime::Applications::TouchEvents::SwipeDown: {
@ -85,7 +107,13 @@ bool Notifications::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
currentId = nextNotification.id;
currentItem.reset(nullptr);
app->SetFullRefresh(DisplayApp::FullRefreshDirections::Down);
currentItem.reset(new NotificationItem("\nNotification", nextNotification.message.data(), nextNotification.index, notificationManager.NbNotifications(), mode));
currentItem.reset(new NotificationItem("\nNotification",
nextNotification.message.data(),
nextNotification.index,
nextNotification.category,
notificationManager.NbNotifications(),
mode,
alertNotificationService));
}
return true;
default:
@ -99,9 +127,26 @@ bool Notifications::OnButtonPushed() {
return true;
}
namespace {
static void AcceptIncomingCallEventHandler(lv_obj_t *obj, lv_event_t event) {
auto* item = static_cast<Notifications::NotificationItem *>(obj->user_data);
item->OnAcceptIncomingCall(event);
}
Notifications::NotificationItem::NotificationItem(const char *title, const char *msg, uint8_t notifNr, uint8_t notifNb, Modes mode)
: notifNr{notifNr}, notifNb{notifNb}, mode{mode} {
static void RejectIncomingCallEventHandler(lv_obj_t *obj, lv_event_t event) {
auto* item = static_cast<Notifications::NotificationItem *>(obj->user_data);
item->OnRejectIncomingCall(event);
}
}
Notifications::NotificationItem::NotificationItem(const char *title,
const char *msg,
uint8_t notifNr,
Controllers::NotificationManager::Categories category,
uint8_t notifNb,
Modes mode,
Pinetime::Controllers::AlertNotificationService& alertNotificationService)
: notifNr{notifNr}, notifNb{notifNb}, mode{mode}, alertNotificationService{alertNotificationService} {
container1 = lv_cont_create(lv_scr_act(), nullptr);
static lv_style_t contStyle;
lv_style_copy(&contStyle, lv_cont_get_style(container1, LV_CONT_STYLE_MAIN));
@ -142,6 +187,8 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
auto titleHeight = lv_obj_get_height(t1);
switch(category) {
default: {
l1 = lv_label_create(container1, nullptr);
lv_label_set_style(l1, LV_LABEL_STYLE_MAIN, &textStyle);
lv_obj_set_pos(l1, textStyle.body.padding.left,
@ -152,6 +199,47 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
lv_label_set_body_draw(l1, true);
lv_obj_set_width(l1, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
lv_label_set_text(l1, msg);
}
break;
case Controllers::NotificationManager::Categories::IncomingCall: {
l1 = lv_label_create(container1, nullptr);
lv_label_set_style(l1, LV_LABEL_STYLE_MAIN, &textStyle);
lv_obj_set_pos(l1, textStyle.body.padding.left,
titleHeight + offscreenOffset + textStyle.body.padding.bottom +
textStyle.body.padding.top);
lv_label_set_long_mode(l1, LV_LABEL_LONG_BREAK);
lv_label_set_body_draw(l1, true);
lv_obj_set_width(l1, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
lv_label_set_text(l1, "Incoming call from ");
auto l1Height = lv_obj_get_height(l1);
l2 = lv_label_create(container1, nullptr);
lv_label_set_style(l2, LV_LABEL_STYLE_MAIN, &textStyle);
lv_obj_set_pos(l2, textStyle.body.padding.left,
titleHeight + l1Height + offscreenOffset + (textStyle.body.padding.bottom*2) +
(textStyle.body.padding.top*2));
lv_label_set_long_mode(l2, LV_LABEL_LONG_BREAK);
lv_label_set_body_draw(l2, true);
lv_obj_set_width(l2, LV_HOR_RES - (textStyle.body.padding.left + textStyle.body.padding.right));
lv_label_set_text(l2, msg);
bt_accept = lv_btn_create(container1, nullptr);
lv_obj_align(bt_accept, lv_scr_act(), LV_ALIGN_IN_BOTTOM_LEFT, 0, -20);
bt_accept->user_data = this;
lv_obj_set_event_cb(bt_accept, AcceptIncomingCallEventHandler);
label_accept = lv_label_create(bt_accept, nullptr);
lv_label_set_text(label_accept, "Accept");
bt_reject = lv_btn_create(container1, nullptr);
lv_obj_align(bt_reject, lv_scr_act(), LV_ALIGN_IN_BOTTOM_RIGHT, 0, -20);
bt_reject->user_data = this;
lv_obj_set_event_cb(bt_reject, RejectIncomingCallEventHandler);
label_reject = lv_label_create(bt_reject, nullptr);
lv_label_set_text(label_reject, "Reject");
}
}
if(mode == Modes::Normal) {
if(notifNr < notifNb) {
@ -166,6 +254,17 @@ Notifications::NotificationItem::NotificationItem(const char *title, const char
}
}
void Notifications::NotificationItem::OnAcceptIncomingCall(lv_event_t event) {
if (event != LV_EVENT_CLICKED) return;
alertNotificationService.AcceptIncomingCall();
}
void Notifications::NotificationItem::OnRejectIncomingCall(lv_event_t event) {
if (event != LV_EVENT_CLICKED) return;
alertNotificationService.RejectIncomingCall();
}
Notifications::NotificationItem::~NotificationItem() {
lv_obj_clean(lv_scr_act());

18
src/displayapp/screens/Notifications.h
View File

@ -19,14 +19,13 @@ namespace Pinetime {
bool OnButtonPushed() override;
bool OnTouchEvent(Pinetime::Applications::TouchEvents event) override;
private:
bool running = true;
class NotificationItem {
public:
NotificationItem(const char* title, const char* msg, uint8_t notifNr, uint8_t notifNb, Modes mode);
NotificationItem(const char* title, const char* msg, uint8_t notifNr, Controllers::NotificationManager::Categories, uint8_t notifNb, Modes mode, Pinetime::Controllers::AlertNotificationService& alertNotificationService);
~NotificationItem();
bool Refresh() {return false;}
void OnAcceptIncomingCall(lv_event_t event);
void OnRejectIncomingCall(lv_event_t event);
private:
uint8_t notifNr = 0;
@ -36,10 +35,21 @@ namespace Pinetime {
lv_obj_t* container1;
lv_obj_t* t1;
lv_obj_t* l1;
lv_obj_t* l2;
lv_obj_t* bt_accept;
lv_obj_t* bt_reject;
lv_obj_t* label_accept;
lv_obj_t* label_reject;
lv_obj_t* bottomPlaceholder;
Modes mode;
Pinetime::Controllers::AlertNotificationService& alertNotificationService;
};
private:
bool running = true;
struct NotificationData {
const char* title;
const char* text;

1
src/displayapp/screens/Tile.cpp
View File

@ -22,7 +22,6 @@ Tile::Tile(DisplayApp* app, std::array<Applications, 6>& applications) : Screen(
appIndex++;
}
}
modal.reset(new Modal(app));
btnm1 = lv_btnm_create(lv_scr_act(), nullptr);
lv_btnm_set_map(btnm1, btnm_map1);

2
src/displayapp/screens/Tile.h
View File

@ -29,8 +29,6 @@ namespace Pinetime {
lv_obj_t * btnm1;
bool running = true;
std::unique_ptr<Modal> modal;
const char* btnm_map1[8];
Pinetime::Applications::Apps apps[6];
};

4
src/main.cpp
View File

@ -98,8 +98,6 @@ void ble_manager_set_ble_disconnection_callback(void (*disconnection)());
static constexpr uint8_t pinTouchIrq = 28;
std::unique_ptr<Pinetime::System::SystemTask> systemTask;
Pinetime::Controllers::NotificationManager notificationManager;
void nrfx_gpiote_evt_handler(nrfx_gpiote_pin_t pin, nrf_gpiote_polarity_t action) {
if(pin == pinTouchIrq) {
systemTask->OnTouchEvent();
@ -241,7 +239,7 @@ int main(void) {
debounceTimer = xTimerCreate ("debounceTimer", 200, pdFALSE, (void *) 0, DebounceTimerCallback);
systemTask.reset(new Pinetime::System::SystemTask(spi, lcd, spiNorFlash, twiMaster, touchPanel, lvgl, batteryController, bleController,
dateTimeController, notificationManager, heartRateSensor));
dateTimeController, heartRateSensor));
systemTask->Start();
nimble_port_init();

7
src/systemtask/SystemTask.cpp
View File

@ -40,13 +40,12 @@ SystemTask::SystemTask(Drivers::SpiMaster &spi, Drivers::St7789 &lcd,
Components::LittleVgl &lvgl,
Controllers::Battery &batteryController, Controllers::Ble &bleController,
Controllers::DateTime &dateTimeController,
Pinetime::Controllers::NotificationManager& notificationManager,
Pinetime::Drivers::Hrs3300& heartRateSensor) :
spi{spi}, lcd{lcd}, spiNorFlash{spiNorFlash},
twiMaster{twiMaster}, touchPanel{touchPanel}, lvgl{lvgl}, batteryController{batteryController},
heartRateController{*this},
bleController{bleController}, dateTimeController{dateTimeController},
watchdog{}, watchdogView{watchdog}, notificationManager{notificationManager},
watchdog{}, watchdogView{watchdog},
heartRateSensor{heartRateSensor},
nimbleController(*this, bleController,dateTimeController, notificationManager, batteryController, spiNorFlash, heartRateController) {
systemTasksMsgQueue = xQueueCreate(10, 1);
@ -161,10 +160,6 @@ void SystemTask::Work() {
if(isSleeping && !isWakingUp) GoToRunning();
displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::NewNotification);
break;
case Messages::OnNewCall:
if(isSleeping && !isWakingUp) GoToRunning();
displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::NewCall);
break;
case Messages::BleConnected:
ReloadIdleTimer();
isBleDiscoveryTimerRunning = true;

3
src/systemtask/SystemTask.h
View File

@ -37,7 +37,6 @@ namespace Pinetime {
Components::LittleVgl &lvgl,
Controllers::Battery &batteryController, Controllers::Ble &bleController,
Controllers::DateTime &dateTimeController,
Pinetime::Controllers::NotificationManager& manager,
Pinetime::Drivers::Hrs3300& heartRateSensor);
@ -73,7 +72,7 @@ namespace Pinetime {
std::atomic<bool> isWakingUp{false};
Pinetime::Drivers::Watchdog watchdog;
Pinetime::Drivers::WatchdogView watchdogView;
Pinetime::Controllers::NotificationManager& notificationManager;
Pinetime::Controllers::NotificationManager notificationManager;
Pinetime::Drivers::Hrs3300& heartRateSensor;
Pinetime::Controllers::NimbleController nimbleController;