~aleteoryx/muditaos

ref: a405cad694b867fcd2498984830bd97d4b9bde2f muditaos/module-apps/apps-common/locks/handlers/PhoneLockHandler.hpp -rw-r--r-- 4.2 KiB
a405cad6 — Aleteoryx trim readme 7 days ago 
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md

#pragma once

#include <locks/widgets/Lock.hpp>
#include <locks/data/PhoneLockMessages.hpp>
#include <locks/data/LockData.hpp>

#include <service-db/Settings.hpp>
#include <Service/Service.hpp>
#include <Timers/TimerHandle.hpp>

namespace locks
{
    constexpr auto phoneLockTimerName                    = "PhoneLockTimer";
    constexpr unsigned initialNoLockTimeAttemptsLeft     = 3;
    constexpr std::time_t initialLockTime                = 15;
    constexpr unsigned phoneLockTimeMultiplier           = 2;

    class PhoneLockHandler
    {
      public:
        enum class RequestReason
        {
            Default = 0, // For default behaviors
            MTPUnlock
        };

      private:
        enum class PhoneState
        {
            Locked,
            Unlocked
        };

        enum class LockTimerState
        {
            Start,
            Counting,
            Stop
        };

        sys::Service *owner = nullptr;
        std::shared_ptr<settings::Settings> settings;
        Lock lock;
        bool phoneLockEnabled = true;

        PhoneState phoneState                             = PhoneState::Locked;
        PhoneLockInputTypeAction phoneLockInputTypeAction = PhoneLockInputTypeAction::Unlock;

        unsigned phoneLockHash = std::numeric_limits<unsigned>::max();
        std::vector<unsigned> storedInputData;

        sys::TimerHandle phoneLockTimer;
        std::time_t lockedFor                 = 0;
        std::time_t nextUnlockAttemptLockTime = 0;

        void setPhoneLockInputTypeAction(PhoneLockInputTypeAction _phoneLockInputTypeAction);
        bool checkPhoneLockInputTypeAction(PhoneLockInputTypeAction _phoneLockInputTypeAction);

        void setPhoneLockInSettings();
        void setPhoneLockAvailabilityInSettings(bool value);
        void setPhoneLockTimeInformationInSettings();
        void savePhoneLockTime();
        void saveNextUnlockAttemptLockTime();
        void saveNoLockTimeAttemptsLeft();

        void phoneLockAction();
        void phoneUnlockAction();
        void phoneLockEnableAction();
        void phoneLockDisableAction();
        void phoneLockChangeAction();
        void phoneLockSetAction();
        void phoneInputRequiredAction(RequestReason reqReason = RequestReason::Default);
        void phoneUnlockPopupsCloseAction();
        void phoneBlockedPopupsCloseAction();
        void phoneLockChangeInfoAction();
        void phoneLockTimeUpdateInfoAction(LockTimerState state);

        void checkNewPhoneLock();
        void resolvePhoneLockAction();

        void processPhoneLockHashCode(LockInput inputData);
        sys::MessagePointer verifyPhoneUnlockInput(LockInput inputData);
        sys::MessagePointer verifyPhoneLockChangeInput(LockInput inputData);

      public:
        PhoneLockHandler(sys::Service *owner, std::shared_ptr<settings::Settings> settings);

        sys::MessagePointer handleLockRequest();
        sys::MessagePointer handleUnlockRequest(RequestReason reqReason = RequestReason::Default);
        sys::MessagePointer handleUnlockCancelRequest();
        sys::MessagePointer handleEnablePhoneLock();
        sys::MessagePointer handleDisablePhoneLock();
        sys::MessagePointer handleChangePhoneLock();
        sys::MessagePointer handleSetPhoneLock();
        sys::MessagePointer handleSkipSetPhoneLock();
        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);
        [[nodiscard]] bool isPhoneLocked() const noexcept;

        void setPhoneLockTime(std::time_t time);
        void setNextUnlockAttemptLockTime(std::time_t time);
        void setNoLockTimeAttemptsLeft(unsigned attemptsNumber);
        void increaseLockTime() noexcept;
        void setNextUnlockAttemptFormattedTime() noexcept;
        void resetLockTime() noexcept;
        void broadcastLockTime() noexcept;
    };
} // namespace locks