4 files changed, 101 insertions(+), 8 deletions(-)

M module-apps/locks/data/PhoneLockMessages.hpp
M module-apps/locks/handlers/PhoneLockHandler.cpp
M module-apps/locks/handlers/PhoneLockHandler.hpp
M module-services/service-appmgr/model/ApplicationManager.cpp

@@ 57,4 57,41 @@ namespace locks
             return inputData;
         }
     };
+
+    class ExternalUnLockPhone : public UnLockPhoneInput
+    {
+      public:
+        explicit ExternalUnLockPhone(std::vector<unsigned int> inputData) : UnLockPhoneInput(std::move(inputData))
+        {}
+    };
+
+    class ExternalPhoneLockAvailabilityChange : public sys::DataMessage
+    {
+      private:
+        bool value = true;
+
+      public:
+        explicit ExternalPhoneLockAvailabilityChange(bool value) : value(value)
+        {}
+
+        [[nodiscard]] auto getAvailability() const noexcept
+        {
+            return value;
+        }
+    };
+
+    class ExternalUnLockPhoneInfo : public sys::DataMessage
+    {
+      private:
+        unsigned int attemptsLeft;
+
+      public:
+        explicit ExternalUnLockPhoneInfo(unsigned int attemptsLeft) : DataMessage{}, attemptsLeft(attemptsLeft)
+        {}
+
+        [[nodiscard]] auto getAttemptsLeft() const noexcept
+        {
+            return attemptsLeft;
+        }
+    };
 } // namespace locks

@@ 121,6 121,12 @@ namespace locks
                                                  gui::popup::ID::PhoneLockChangeInfo, lock, phoneLockInputTypeAction));
     }
 
+    void PhoneLockHandler::phoneExternalUnlockInfoAction()
+    {
+        owner->bus.sendMulticast(std::make_shared<locks::ExternalUnLockPhoneInfo>(lock.getAttemptsLeft()),
+                                 sys::BusChannel::PhoneLockChanges);
+    }
+
     void PhoneLockHandler::setPhoneLockInSettings()
     {
         phoneLockHash = getHash(storedInputData);


@@ 234,7 240,7 @@ namespace locks
         phoneInputRequiredAction();
     }
 
-    sys::MessagePointer PhoneLockHandler::verifyPhoneLockInput(LockInput inputData)
+    sys::MessagePointer PhoneLockHandler::handlePhoneLockInput(LockInput inputData)
     {
         if (checkPhoneLockInputTypeAction(PhoneLockInputTypeAction::Enable) ||
             checkPhoneLockInputTypeAction(PhoneLockInputTypeAction::Change) ||


@@ 246,7 252,7 @@ namespace locks
         }
     }
 
-    sys::MessagePointer PhoneLockHandler::verifyPhoneUnlockInput(LockInput inputData)
+    void PhoneLockHandler::comparePhoneLockHashCode(LockInput inputData)
     {
         const uint32_t hash = getHash(inputData);
         lock.attemptsLeft--;


@@ 254,8 260,6 @@ namespace locks
         if (phoneLockHash == hash) {
             lock.lockState    = Lock::LockState::Unlocked;
             lock.attemptsLeft = default_attempts;
-            resolvePhoneLockAction();
-            return sys::msgHandled();
         }
         else if (lock.attemptsLeft > 0) {
             lock.lockState = Lock::LockState::InputInvalid;


@@ 263,8 267,18 @@ namespace locks
         else {
             lock.lockState = Lock::LockState::Blocked;
         }
+    }
 
-        phoneInputRequiredAction();
+    sys::MessagePointer PhoneLockHandler::verifyPhoneUnlockInput(LockInput inputData)
+    {
+        comparePhoneLockHashCode(inputData);
+
+        if (lock.isState(Lock::LockState::Unlocked)) {
+            resolvePhoneLockAction();
+        }
+        else {
+            phoneInputRequiredAction();
+        }
 
         return sys::msgHandled();
     }


@@ 287,7 301,37 @@ namespace locks
 
         phoneInputRequiredAction();
 
-        return sys::MessagePointer();
+        return sys::msgHandled();
+    }
+
+    sys::MessagePointer PhoneLockHandler::handleExternalUnlockRequest(LockInput inputData)
+    {
+        if (!phoneLockEnabled) {
+            phoneUnlockAction();
+            return sys::msgHandled();
+        }
+
+        if (lock.isState(Lock::LockState::Blocked)) {
+            phoneExternalUnlockInfoAction();
+            return sys::msgHandled();
+        }
+
+        comparePhoneLockHashCode(inputData);
+
+        if (lock.isState(Lock::LockState::Unlocked)) {
+            phoneUnlockAction();
+        }
+        else {
+            phoneExternalUnlockInfoAction();
+        }
+
+        return sys::msgHandled();
+    }
+
+    sys::MessagePointer PhoneLockHandler::handleExternalAvailabilityChange(bool value)
+    {
+        setPhoneLockAvailabilityInSettings(value);
+        return sys::msgHandled();
     }
 
     void PhoneLockHandler::resolvePhoneLockAction()

@@ 45,10 45,12 @@ namespace locks
         void phoneInputRequiredAction();
         void phoneUnlockPopupsCloseAction();
         void phoneLockChangeInfoAction();
+        void phoneExternalUnlockInfoAction();
 
         void checkNewPhoneLock();
         void resolvePhoneLockAction();
 
+        void comparePhoneLockHashCode(LockInput inputData);
         sys::MessagePointer verifyPhoneUnlockInput(LockInput inputData);
         sys::MessagePointer verifyPhoneLockChangeInput(LockInput inputData);
 


@@ 63,7 65,9 @@ namespace locks
         sys::MessagePointer handleChangePhoneLock();
         sys::MessagePointer handleSetPhoneLock();
         sys::MessagePointer handleSkipSetPhoneLock();
-        sys::MessagePointer verifyPhoneLockInput(LockInput inputData);
+        sys::MessagePointer handlePhoneLockInput(LockInput inputData);
+        sys::MessagePointer handleExternalUnlockRequest(LockInput inputData);
+        sys::MessagePointer handleExternalAvailabilityChange(bool value);
 
         void enablePhoneLock(bool _phoneLockEnabled);
         void setPhoneLockHash(const std::string &value);

@@ 437,7 437,7 @@ namespace app::manager
         });
         connect(typeid(locks::UnLockPhoneInput), [&](sys::Message *request) -> sys::MessagePointer {
             auto data = static_cast<locks::UnLockPhoneInput *>(request);
-            return phoneLockHandler.verifyPhoneLockInput(data->getInputData());
+            return phoneLockHandler.handlePhoneLockInput(data->getInputData());
         });
         connect(typeid(locks::EnablePhoneLock),
                 [&](sys::Message *request) -> sys::MessagePointer { return phoneLockHandler.handleEnablePhoneLock(); });


@@ 463,6 463,14 @@ namespace app::manager
             auto req = static_cast<SetAutoLockTimeoutRequest *>(request);
             return handleAutoLockSetRequest(req);
         });
+        connect(typeid(locks::ExternalUnLockPhone), [&](sys::Message *request) -> sys::MessagePointer {
+            auto data = static_cast<locks::ExternalUnLockPhone *>(request);
+            return phoneLockHandler.handleExternalUnlockRequest(data->getInputData());
+        });
+        connect(typeid(locks::ExternalPhoneLockAvailabilityChange), [&](sys::Message *request) -> sys::MessagePointer {
+            auto data = static_cast<locks::ExternalPhoneLockAvailabilityChange *>(request);
+            return phoneLockHandler.handleExternalAvailabilityChange(data->getAvailability());
+        });
 
         // SimLock connects
         connect(typeid(cellular::msg::notification::SimNeedPin), [&](sys::Message *request) -> sys::MessagePointer {