20 files changed, 92 insertions(+), 2 deletions(-)

A art/phone/home_notifications/._Icon_
A art/phone/home_notifications/alarm_notification_icon.png
A art/phone/home_notifications/calendar_notification_icon.png
A art/phone/home_notifications/calls_notification_icon.png
A art/phone/home_notifications/messages_notification_icon.png
A art/phone/home_notifications/now_playing_notification_icon.png
A art/phone/home_notifications/tethering_notification_icon.png
A image/assets/images/tethering_notification_icon.vpi
M module-apps/application-desktop/models/ActiveNotificationsModel.cpp
M module-apps/application-desktop/models/ActiveNotificationsModel.hpp
M module-apps/notifications/NotificationData.cpp
M module-apps/notifications/NotificationData.hpp
M module-apps/notifications/NotificationListItem.cpp
M module-apps/notifications/NotificationListItem.hpp
M module-apps/notifications/NotificationProvider.cpp
M module-apps/notifications/NotificationProvider.hpp
M module-apps/notifications/NotificationsModel.cpp
M module-apps/notifications/NotificationsModel.hpp
M module-services/service-appmgr/model/ApplicationManager.cpp
M module-services/service-appmgr/service-appmgr/model/ApplicationManager.hpp

@@ 6,6 6,7 @@
 #include <service-appmgr/Controller.hpp>
 #include <application-messages/ApplicationMessages.hpp>
 #include <application-call/data/CallSwitchData.hpp>
+#include <SystemManager/messages/TetheringStateRequest.hpp>
 
 using namespace gui;
 


@@ 98,3 99,22 @@ auto ActiveNotificationsModel::create(const notifications::NotSeenCallNotificati
     item->setDismissible(true);
     return item;
 }
+
+auto ActiveNotificationsModel::create(const notifications::TetheringNotification *notification)
+    -> NotificationListItem *
+{
+    auto item               = NotificationsModel::create(notification);
+    item->activatedCallback = [this]([[maybe_unused]] gui::Item &_item) {
+        return parent->getApplication()->bus.sendUnicast(
+            std::make_shared<sys::TetheringStateRequest>(sys::phone_modes::Tethering::Off),
+            service::name::system_manager);
+    };
+    item->focusChangedCallback = [this](gui::Item &_item) {
+        if (_item.focus) {
+            setParentBottomBar({}, utils::translate("common_disconnect"), {});
+            return true;
+        }
+        return false;
+    };
+    return item;
+}

@@ 12,5 12,6 @@ namespace gui
         void setParentBottomBar(const UTF8 &left, const UTF8 &center, const UTF8 &right);
         auto create(const notifications::NotSeenSMSNotification *notification) -> NotificationListItem * override;
         auto create(const notifications::NotSeenCallNotification *notification) -> NotificationListItem * override;
+        auto create(const notifications::TetheringNotification *notification) -> NotificationListItem * override;
     };
 } // namespace gui

@@ 62,3 62,6 @@ auto NotSeenCallNotification::getValue() const noexcept -> unsigned
 {
     return value;
 }
+
+TetheringNotification::TetheringNotification() : Notification(NotificationType::Tethering)
+{}

@@ 15,6 15,7 @@ namespace notifications
         Unknown,
         NotSeenSms,
         NotSeenCall,
+        Tethering
     };
 
     enum class NotificationPriority


@@ 65,4 66,10 @@ namespace notifications
         [[nodiscard]] auto getValue() const noexcept -> unsigned;
     };
 
+    class TetheringNotification : public Notification
+    {
+      public:
+        TetheringNotification();
+    };
+
 } // namespace notifications

@@ 86,7 86,7 @@ namespace
         {notifications::NotificationType::Unknown, "phone"},
         {notifications::NotificationType::NotSeenSms, "mail"},
         {notifications::NotificationType::NotSeenCall, "phone"},
-    };
+        {notifications::NotificationType::Tethering, "tethering_notification_icon"}};
 } // namespace
 
 NotificationListItem::NotificationListItem(NotificationType type) : type{type}


@@ 136,3 136,11 @@ NotificationWithEventCounter::NotificationWithEventCounter(notifications::Notifi
     box->addWidget(buildImageInactive("dot_12px_hard_alpha_W_G"));
     box->addWidget(buildNotificationCountText(indicator));
 }
+
+NotificationWithOnOffButton::NotificationWithOnOffButton(notifications::NotificationType type, gui::ButtonState state)
+    : NotificationListItem(type)
+{
+    auto button = new ButtonOnOff(nullptr, state);
+    button->setMargins(Margins(0, 0, 20, 0));
+    box->addWidget(button);
+}

@@ 7,6 7,7 @@
 #include <BoxLayout.hpp>
 #include <Text.hpp>
 #include <RichTextParser.hpp>
+#include <widgets/ButtonOnOff.hpp>
 
 #include "NotificationData.hpp"
 


@@ 40,4 41,11 @@ namespace gui
         NotificationWithEventCounter(notifications::NotificationType type, const UTF8 &indicator);
     };
 
+    class NotificationWithOnOffButton : public NotificationListItem
+    {
+
+      public:
+        NotificationWithOnOffButton(notifications::NotificationType type, gui::ButtonState state);
+    };
+
 } // namespace gui

@@ 65,6 65,25 @@ void NotificationProvider::handle(db::NotificationMessage *msg)
     }
 }
 
+void NotificationProvider::handle(sys::phone_modes::Tethering tethering)
+{
+    using Tethering           = sys::phone_modes::Tethering;
+    bool notificationsChanged = false;
+
+    if (tethering == Tethering::On && notifications.count(NotificationType::Tethering) == 0) {
+        notifications[NotificationType::Tethering] = std::make_shared<notifications::TetheringNotification>();
+        notificationsChanged                       = true;
+    }
+    else if (tethering == Tethering::Off && notifications.count(NotificationType::Tethering) != 0) {
+        notifications.erase(NotificationType::Tethering);
+        notificationsChanged = true;
+    }
+
+    if (notificationsChanged) {
+        send();
+    }
+}
+
 void NotificationProvider::requestNotSeenNotifications()
 {
     DBServiceAPI::GetQuery(

@@ 4,6 4,7 @@
 #pragma once
 
 #include "NotificationData.hpp"
+#include <PhoneModes/Common.hpp>
 
 namespace sys
 {


@@ 31,6 32,7 @@ namespace notifications
 
         void handle(db::query::notifications::GetAllResult *msg);
         void handle(db::NotificationMessage *msg);
+        void handle(sys::phone_modes::Tethering tethering);
         void requestNotSeenNotifications();
         void send();
 

@@ 74,6 74,14 @@ auto NotificationsModel::create(const notifications::NotSeenCallNotification *no
     return item;
 }
 
+auto NotificationsModel::create(const notifications::TetheringNotification *notification) -> NotificationListItem *
+{
+    auto item = new NotificationWithOnOffButton(notifications::NotificationType::Tethering, gui::ButtonState::On);
+    item->setName(utils::translate("Tethering"), false);
+    item->deleteByList = false;
+    return item;
+}
+
 void NotificationsModel::updateData(app::manager::actions::NotificationsChangedParams *params)
 {
     if (list == nullptr) {


@@ 86,7 94,6 @@ void NotificationsModel::updateData(app::manager::actions::NotificationsChangedP
             delete item;
         }
     };
-
     for (const auto &notification : params->getNotifications()) {
         if (typeid(*notification) == typeid(notifications::NotSeenSMSNotification)) {
             auto sms = static_cast<const notifications::NotSeenSMSNotification *>(notification.get());


@@ 96,6 103,10 @@ void NotificationsModel::updateData(app::manager::actions::NotificationsChangedP
             auto call = static_cast<const notifications::NotSeenCallNotification *>(notification.get());
             internalData.push_back(create(call));
         }
+        else if (typeid(*notification) == typeid(notifications::TetheringNotification)) {
+            auto tethering = static_cast<const notifications::TetheringNotification *>(notification.get());
+            internalData.push_back(create(tethering));
+        }
     }
 
     list->rebuildList(listview::RebuildType::InPlace);

@@ 27,6 27,8 @@ namespace gui
             -> NotificationListItem *;
         [[nodiscard]] virtual auto create(const notifications::NotSeenCallNotification *notification)
             -> NotificationListItem *;
+        [[nodiscard]] virtual auto create(const notifications::TetheringNotification *notification)
+            -> NotificationListItem *;
 
       public:
         [[nodiscard]] bool isEmpty() const noexcept;

@@ 279,6 279,9 @@ namespace app::manager
                 ActionEntry{actions::ShowPopup, std::make_unique<gui::PhoneModePopupRequestParams>(phoneMode)});
         });
 
+        phoneModeObserver->subscribe(
+            [this](sys::phone_modes::Tethering tethering) { handleTetheringChanged(tethering); });
+
         connect(typeid(StartAllowedMessage), [this](sys::Message *request) {
             auto msg = static_cast<StartAllowedMessage *>(request);
             handleStart(msg);


@@ 583,6 586,11 @@ namespace app::manager
         actionsRegistry.enqueue(std::move(action));
     }
 
+    void ApplicationManager::handleTetheringChanged(sys::phone_modes::Tethering tethering)
+    {
+        notificationProvider.handle(tethering);
+    }
+
     ActionProcessStatus ApplicationManager::handleAction(ActionEntry &action)
     {
         switch (action.actionId) {

@@ 128,6 128,7 @@ namespace app::manager
         auto handleActionOnFocusedApp(ActionEntry &action) -> ActionProcessStatus;
         auto handlePhoneModeChangedAction(ActionEntry &action) -> ActionProcessStatus;
         void handlePhoneModeChanged(sys::phone_modes::PhoneMode phoneMode);
+        void handleTetheringChanged(sys::phone_modes::Tethering tethering);
         void changePhoneMode(sys::phone_modes::PhoneMode phoneMode, const ApplicationHandle *app);
         auto handleCustomAction(ActionEntry &action) -> ActionProcessStatus;
         auto handleSwitchApplication(SwitchRequest *msg, bool closeCurrentlyFocusedApp = true) -> bool;