20 files changed, 54 insertions(+), 142 deletions(-)

M module-apps/Application.hpp
M module-apps/application-desktop/ApplicationDesktop.cpp
M module-apps/application-desktop/ApplicationDesktop.hpp
M module-apps/locks/data/LockMessages.hpp
M module-apps/locks/handlers/PhoneLockHandler.cpp
M module-apps/locks/handlers/PhoneLockHandler.hpp
M module-apps/locks/handlers/PhoneLockSubject.cpp
M module-apps/locks/handlers/PhoneLockSubject.hpp
M module-apps/locks/handlers/PinLockHandler.cpp
M module-apps/locks/handlers/PinLockHandler.hpp
M module-services/service-appmgr/CMakeLists.txt
D module-services/service-appmgr/data/UsbActionsParams.cpp
M module-services/service-appmgr/model/ApplicationManager.cpp
M module-services/service-appmgr/service-appmgr/Actions.hpp
D module-services/service-appmgr/service-appmgr/data/UsbActionsParams.hpp
M module-services/service-desktop/ServiceDesktop.cpp
M module-services/service-desktop/endpoints/developerMode/DeveloperModeHelper.cpp
M module-services/service-desktop/service-desktop/DesktopMessages.hpp
M module-sys/Service/Common.hpp
M source/MessageType.hpp

@@ 394,7 394,7 @@ namespace app
         std::unique_ptr<settings::Settings> settings;
         sys::phone_modes::PhoneMode phoneMode;
 
-        lock::PhoneLockSubject phoneLockSubject;
+        locks::PhoneLockSubject phoneLockSubject;
 
       public:
         void handlePhoneLock();

@@ 86,11 86,6 @@ namespace app
             return actionHandled();
         });
 
-        addActionReceiver(app::manager::actions::RequestScreenPasscode, [this](auto &&data) {
-            lockHandler.handleScreenPasscodeRequest(std::move(data));
-            return actionHandled();
-        });
-
         addActionReceiver(app::manager::actions::RequestPuk, [this](auto &&data) {
             lockHandler.handlePasscodeRequest(locks::Lock::LockType::SimPuk, std::move(data));
             return actionHandled();

@@ 125,7 125,6 @@ namespace app
                      manager::actions::RequestPinChange,
                      manager::actions::RequestPinDisable,
                      manager::actions::RequestPinEnable,
-                     manager::actions::RequestScreenPasscode,
                      manager::actions::UnlockSim,
                      manager::actions::BlockSim,
                      manager::actions::ShowMMIResponse,

@@ 5,30 5,43 @@
 
 #include <Service/Message.hpp>
 
-namespace lock
+namespace locks
 {
     class UnlockPhone : public sys::DataMessage
     {
       public:
-        UnlockPhone() : DataMessage{MessageType::MessageTypeUninitialized}
+        UnlockPhone() : DataMessage{}
+        {}
+    };
+
+    class CancelUnlockPhone : public sys::DataMessage
+    {
+      public:
+        CancelUnlockPhone() : DataMessage{}
+        {}
+    };
+
+    class UnlockedPhone : public sys::DataMessage
+    {
+      public:
+        UnlockedPhone() : DataMessage{}
         {}
     };
 
     class LockPhone : public sys::DataMessage
     {
       public:
-        LockPhone() : DataMessage{MessageType::MessageTypeUninitialized}
+        LockPhone() : DataMessage{}
         {}
     };
 
-    class LockPhoneInput : public sys::DataMessage
+    class UnLockPhoneInput : public sys::DataMessage
     {
       private:
         std::vector<unsigned int> inputData;
 
       public:
-        explicit LockPhoneInput(std::vector<unsigned int> inputData)
-            : DataMessage{MessageType::MessageTypeUninitialized}, inputData(std::move(inputData))
+        explicit UnLockPhoneInput(std::vector<unsigned int> inputData) : DataMessage{}, inputData(std::move(inputData))
         {}
 
         [[nodiscard]] auto getInputData() const noexcept

@@ 40,7 40,7 @@ namespace locks
                                              std::make_unique<gui::PopupRequestParams>(gui::popup::ID::PhoneLock));
     }
 
-    void PhoneLockHandler::PhoneUnlockAction()
+    void PhoneLockHandler::PhoneUnlockPopupsCloseAction()
     {
         app::manager::Controller::sendAction(owner,
                                              app::manager::actions::AbortPopup,


@@ 50,6 50,12 @@ namespace locks
                                              std::make_unique<gui::PopupRequestParams>(gui::popup::ID::PhoneLock));
     }
 
+    void PhoneLockHandler::PhoneUnlockAction()
+    {
+        PhoneUnlockPopupsCloseAction();
+        owner->bus.sendMulticast(std::make_shared<locks::UnlockedPhone>(), sys::BusChannel::PhoneLockChanges);
+    }
+
     void PhoneLockHandler::PhoneInputRequiredAction()
     {
         app::manager::Controller::sendAction(


@@ 112,9 118,14 @@ namespace locks
         return sys::msgHandled();
     }
 
+    sys::MessagePointer PhoneLockHandler::handleUnlockCancelRequest()
+    {
+        PhoneUnlockPopupsCloseAction();
+        return sys::msgHandled();
+    }
+
     bool PhoneLockHandler::isPhoneLocked() const noexcept
     {
         return !lock.isState(Lock::LockState::Unlocked);
     }
-
 } // namespace locks

@@ 21,12 21,14 @@ namespace locks
         void PhoneLockAction();
         void PhoneUnlockAction();
         void PhoneInputRequiredAction();
+        void PhoneUnlockPopupsCloseAction();
 
       public:
         explicit PhoneLockHandler(sys::Service *owner);
 
         sys::MessagePointer handleLockRequest();
         sys::MessagePointer handleUnlockRequest();
+        sys::MessagePointer handleUnlockCancelRequest();
         sys::MessagePointer verifyPhoneLockInput(const std::vector<unsigned int> &inputData);
 
         void enablePhoneLock(bool _phoneLockEnabled);

@@ 6,7 6,7 @@
 #include <service-appmgr/service-appmgr/model/ApplicationManager.hpp>
 #include <locks/data/LockMessages.hpp>
 
-namespace lock
+namespace locks
 {
     PhoneLockSubject::PhoneLockSubject(sys::Service *owner) : owner{owner}
     {


@@ 27,7 27,7 @@ namespace lock
 
     void PhoneLockSubject::verifyInput(const std::vector<unsigned int> &inputData)
     {
-        owner->bus.sendUnicast(std::make_shared<LockPhoneInput>(inputData),
+        owner->bus.sendUnicast(std::make_shared<UnLockPhoneInput>(inputData),
                                app::manager::ApplicationManager::ServiceName);
     }
 } // namespace lock

@@ 5,7 5,7 @@
 
 #include <module-sys/Service/Service.hpp>
 
-namespace lock
+namespace locks
 {
     class PhoneLockSubject
     {

@@ 78,29 78,6 @@ namespace gui
         }
     }
 
-    void PinLockHandler::handleScreenPasscodeRequest(app::manager::actions::ActionParamsPtr &&data) const
-    {
-        auto params = static_cast<app::manager::actions::ScreenPasscodeParams *>(data.get());
-        auto lock =
-            std::make_unique<gui::Lock>(Store::GSM::SIM::NONE, Lock::LockState::InputRequired, Lock::LockType::Screen);
-
-        if (params->isCancel()) {
-            if (app->getCurrentWindow()->getName() == app::window::name::desktop_pin_lock) {
-                app->returnToPreviousWindow();
-            }
-            return;
-        }
-
-        lock->onActivatedCallback = [this](Lock::LockType type, const std::vector<unsigned int> &data) {
-            app->bus.sendUnicast(std::make_shared<sdesktop::passcode::ScreenPasscodeUnlocked>(),
-                                 service::name::service_desktop);
-            app->switchWindow(app::window::name::desktop_main_window);
-        };
-
-        app->switchWindow(
-            app::window::name::desktop_pin_lock, gui::ShowMode::GUI_SHOW_INIT, std::make_unique<gui::LockData>(*lock));
-    }
-
     void PinLockHandler::handlePinChangeRequest(app::manager::actions::ActionParamsPtr &&data)
     {
         LOG_DEBUG("Handling RequestPinChange action");

@@ 58,7 58,6 @@ namespace gui
         void handleSimBlocked(app::manager::actions::ActionParamsPtr &&data);
         void handleUnlockSim(app::manager::actions::ActionParamsPtr &&data);
         void handleCMEError(app::manager::actions::ActionParamsPtr &&data) const;
-        void handleScreenPasscodeRequest(app::manager::actions::ActionParamsPtr &&data) const;
         void handlePinChangeRequestFailed();
 
         [[nodiscard]] auto isScreenLocked() const noexcept -> bool

@@ 4,7 4,6 @@ message( "${PROJECT_NAME}  ${CMAKE_CURRENT_LIST_DIR}" )
 set(SOURCES
     ApplicationManifest.cpp
     Controller.cpp
-    data/UsbActionsParams.cpp
     data/SimActionsParams.cpp
     data/MmiActionsParams.cpp
     data/NotificationsChangedActionsParams.cpp

@@ 1,23 0,0 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#include <service-appmgr/data/UsbActionsParams.hpp>
-
-using namespace app::manager::actions;
-
-ScreenPasscodeParams::ScreenPasscodeParams(bool cancel, unsigned int _attempts, std::string _passcodeName)
-    : cancel(cancel), attempts{_attempts}, passcodeName{std::move(_passcodeName)}
-{}
-
-unsigned int ScreenPasscodeParams::getAttempts() const noexcept
-{
-    return attempts;
-}
-const std::string &ScreenPasscodeParams::getPasscodeName() const noexcept
-{
-    return passcodeName;
-}
-bool ScreenPasscodeParams::isCancel() const noexcept
-{
-    return cancel;
-}

@@ 419,12 419,15 @@ namespace app::manager
             handleDBResponse(response);
             return sys::msgHandled();
         });
-        connect(typeid(lock::LockPhone),
+        connect(typeid(locks::LockPhone),
                 [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleLockRequest(); });
-        connect(typeid(lock::UnlockPhone),
+        connect(typeid(locks::UnlockPhone),
                 [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleUnlockRequest(); });
-        connect(typeid(lock::LockPhoneInput), [&](sys::Message *request) -> sys::MessagePointer {
-            auto msg = static_cast<lock::LockPhoneInput *>(request);
+        connect(typeid(locks::CancelUnlockPhone), [&](sys::Message *request) -> sys::MessagePointer {
+            return phoneLockHandler.handleUnlockCancelRequest();
+        });
+        connect(typeid(locks::UnLockPhoneInput), [&](sys::Message *request) -> sys::MessagePointer {
+            auto msg = static_cast<locks::UnLockPhoneInput *>(request);
             return phoneLockHandler.verifyPhoneLockInput(msg->getInputData());
         });
 


@@ 443,7 446,6 @@ namespace app::manager
         connect(typeid(CellularNotAnEmergencyNotification), convertibleToActionHandler);
         connect(typeid(sys::CriticalBatteryLevelNotification), convertibleToActionHandler);
         connect(typeid(CellularSmsNoSimRequestMessage), convertibleToActionHandler);
-        connect(typeid(sdesktop::passcode::ScreenPasscodeRequest), convertibleToActionHandler);
         connect(typeid(CellularSMSRejectedByOfflineNotification), convertibleToActionHandler);
         connect(typeid(CellularCallRejectedByOfflineNotification), convertibleToActionHandler);
         connect(typeid(sys::TetheringQuestionRequest), convertibleToActionHandler);

@@ 56,7 56,6 @@ namespace app::manager
             DisplayCMEError,
             DisplayLowBatteryScreen,
             SystemBrownout,
-            RequestScreenPasscode,
             DisplayLogoAtExit,
             SMSRejectedByOfflineNotification,
             CallRejectedByOfflineNotification,

@@ 1,27 0,0 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#pragma once
-
-#include <service-appmgr/service-appmgr/Actions.hpp>
-#include <module-utils/common_data/EventStore.hpp>
-
-namespace app::manager::actions
-{
-    /** Action parameters for
-     * RequestScreenPasscode
-     */
-    class ScreenPasscodeParams : public ActionParams
-    {
-        bool cancel           = false;
-        unsigned int attempts = 0;
-        std::string passcodeName;
-
-      public:
-        ScreenPasscodeParams(bool cancel, unsigned int _attempts = 0, std::string _passcodeName = "Screen");
-
-        [[nodiscard]] unsigned int getAttempts() const noexcept;
-        [[nodiscard]] const std::string &getPasscodeName() const noexcept;
-        [[nodiscard]] bool isCancel() const noexcept;
-    };
-} // namespace app::manager::actions

@@ 65,6 65,7 @@ ServiceDesktop::ServiceDesktop()
       btMsgHandler(std::make_unique<sdesktop::bluetooth::BluetoothMessagesHandler>(this))
 {
     LOG_INFO("[ServiceDesktop] Initializing");
+    bus.channels.push_back(sys::BusChannel::PhoneLockChanges);
 
     updateOS         = std::make_unique<UpdateMuditaOS>(this);
     settings         = std::make_unique<settings::Settings>(this);


@@ 224,8 225,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
 
         LOG_INFO("USB connected with endpoint security enabled. Requesting passcode.");
         usbSecurityModel->setEndpointSecurity(EndpointSecurity::Block);
-        bus.sendUnicast(std::make_shared<sdesktop::passcode::ScreenPasscodeRequest>(),
-                        app::manager::ApplicationManager::ServiceName);
+        bus.sendUnicast(std::make_shared<locks::UnlockPhone>(), app::manager::ApplicationManager::ServiceName);
 
         return sys::MessageNone{};
     });


@@ 234,7 234,7 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
         LOG_INFO("USB disconnected");
         if (usbSecurityModel->isSecurityEnabled()) {
             LOG_INFO("Enabling secured endpoints.");
-            bus.sendUnicast(std::make_shared<sdesktop::passcode::ScreenPasscodeRequest>(true),
+            bus.sendUnicast(std::make_shared<locks::CancelUnlockPhone>(),
                             app::manager::ApplicationManager::ServiceName);
         }
         bus.sendUnicast(std::make_shared<sys::TetheringStateRequest>(sys::phone_modes::Tethering::Off),


@@ 258,10 258,8 @@ sys::ReturnCodes ServiceDesktop::InitHandler()
         return sys::MessageNone{};
     });
 
-    connect(sdesktop::passcode::ScreenPasscodeUnlocked(), [&](sys::Message *msg) {
+    connect(typeid(locks::UnlockedPhone), [&](sys::Message *msg) {
         LOG_INFO("Passcode accepted. Enabling endpoints.");
-        bus.sendUnicast(std::make_shared<sdesktop::passcode::ScreenPasscodeRequest>(true),
-                        app::manager::ApplicationManager::ServiceName);
         usbSecurityModel->setEndpointSecurity(EndpointSecurity::Allow);
         return sys::MessageNone{};
     });


@@ 355,7 353,7 @@ void ServiceDesktop::processUSBHandshake(sdesktop::usb::USBHandshake *msg)
 
     if (usbSecurityModel->processHandshake(msg)) {
         LOG_DEBUG("Handshake ok. Unlocking.");
-        bus.sendUnicast(std::make_shared<sdesktop::passcode::ScreenPasscodeUnlocked>(), service::name::service_desktop);
+        bus.sendUnicast(std::make_shared<locks::UnlockedPhone>(), service::name::service_desktop);
         responseContext.setResponseStatus(parserFSM::http::Code::OK);
     }
 

@@ 115,7 115,7 @@ auto DeveloperModeHelper::processPut(Context &context) -> ProcessResult
     else if (body[json::developerMode::usbSecurityStatus].is_string()) {
         std::shared_ptr<sys::DataMessage> msg = std::make_shared<sdesktop::usb::USBConfigured>();
         if (body[json::developerMode::usbSecurityStatus].string_value() == json::developerMode::usbUnlocked) {
-            msg = std::make_shared<sdesktop::passcode::ScreenPasscodeUnlocked>();
+            msg = std::make_shared<locks::UnlockedPhone>();
         }
         code = toCode(owner->bus.sendUnicast(std::move(msg), "ServiceDesktop"));
     }

@@ 9,7 9,6 @@
 #include <service-appmgr/Actions.hpp>
 #include <service-appmgr/messages/ActionRequest.hpp>
 #include <service-appmgr/data/SimActionsParams.hpp>
-#include <service-appmgr/data/UsbActionsParams.hpp>
 #include <Service/Message.hpp>
 #include <MessageType.hpp>
 #include <service-desktop/DeveloperModeMessage.hpp>


@@ 148,37 147,6 @@ namespace sdesktop
 
     } // namespace usb
 
-    namespace passcode
-    {
-        class ScreenPasscodeRequest : public sys::DataMessage, public app::manager::actions::ConvertibleToAction
-        {
-            static constexpr auto passcodeName = "ScreenPasscode";
-
-          public:
-            explicit ScreenPasscodeRequest(bool cancel = false)
-                : sys::DataMessage(MessageType::ScreenPasscodeRequest), cancel(cancel)
-            {}
-
-            [[nodiscard]] auto toAction() const -> std::unique_ptr<app::manager::ActionRequest>
-            {
-                return std::make_unique<app::manager::ActionRequest>(
-                    sender,
-                    app::manager::actions::RequestScreenPasscode,
-                    std::make_unique<app::manager::actions::ScreenPasscodeParams>(cancel));
-            }
-
-          private:
-            bool cancel = false;
-        };
-
-        class ScreenPasscodeUnlocked : public sys::DataMessage
-        {
-          public:
-            explicit ScreenPasscodeUnlocked() : sys::DataMessage(MessageType::ScreenPasscodeUnlocked)
-            {}
-        }; // namespace sdesktop
-    }      // namespace passcode
-
     namespace developerMode
     {
         class AppFocusChangeEvent : public Event

@@ 25,6 25,7 @@ namespace sys
         ServiceEvtmgrNotifications,
         CalendarNotifications,
         PhoneModeChanges,
+        PhoneLockChanges,
     };
 
     enum class ServicePriority


@@ 114,6 115,8 @@ inline const char *c_str(sys::BusChannel channel)
         return "CalendarNotifications";
     case sys::BusChannel::PhoneModeChanges:
         return "PhoneModeChanges";
+    case sys::BusChannel::PhoneLockChanges:
+        return "PhoneLockChanges";
     }
     return "";
 }

@@ 127,9 127,6 @@ enum class MessageType
     USBSecurityOff,
     USBHandshake,
 
-    ScreenPasscodeRequest,
-    ScreenPasscodeUnlocked,
-
     // FOTA messages
     HttpRequest,
     HttpResponse,