~aleteoryx/muditaos

muditaos/module-services/service-time/AlarmMessageHandler.hpp -rw-r--r-- 3.3 KiB
a405cad6 — Aleteoryx trim readme 6 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

// 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 "AlarmOperations.hpp"

#include <service-time/AlarmMessage.hpp>
#include <service-evtmgr/BatteryMessages.hpp>
#include <Service/Service.hpp>

namespace stm
{
    class ServiceTime;
}

namespace alarms
{
    class AlarmMessageHandler
    {
      public:
        AlarmMessageHandler(stm::ServiceTime *service, std::unique_ptr<IAlarmOperations> &&alarmOperations);

        auto handleTimeUpdate(TimePoint time) -> void;
        auto handleGetAlarm(AlarmGetRequestMessage *request) -> std::shared_ptr<AlarmGetResponseMessage>;
        auto handleGetAlarmWithStatus(AlarmGetWithStatusRequestMessage *request)
            -> std::shared_ptr<AlarmGetWithStatusResponseMessage>;
        auto handleAddAlarm(AlarmAddRequestMessage *request) -> std::shared_ptr<AlarmAddResponseMessage>;
        auto handleUpdateAlarm(AlarmUpdateRequestMessage *request) -> std::shared_ptr<AlarmUpdateResponseMessage>;
        auto handleRemoveAlarm(AlarmRemoveRequestMessage *request) -> std::shared_ptr<AlarmRemoveResponseMessage>;
        auto handleGetAlarmsInRange(AlarmsGetInRangeRequestMessage *request)
            -> std::shared_ptr<AlarmsGetInRangeResponseMessage>;
        auto handleGetNextSingleEvents(AlarmGetNextSingleEventsRequestMessage *request)
            -> std::shared_ptr<AlarmGetNextSingleEventsResponseMessage>;
        auto handleTurnOffRingingAlarm(RingingAlarmTurnOffRequestMessage *request)
            -> std::shared_ptr<RingingAlarmTurnOffResponseMessage>;
        auto handleTurnOffSnooze(TurnOffSnoozeRequestMessage *request) -> std::shared_ptr<TurnOffSnoozeResponseMessage>;
        auto handleSnoozeRingingAlarm(RingingAlarmSnoozeRequestMessage *request)
            -> std::shared_ptr<RingingAlarmSnoozeResponseMessage>;
        auto handlePostponeSnooze(PostponeSnoozeRequestMessage *request)
            -> std::shared_ptr<PostponeSnoozeResponseMessage>;
        auto handleMinuteUpdated() -> void;
        auto handleStopAllSnoozedAlarms() -> void;
        auto handleAddSnoozedAlarmCountChangeCallback(AlarmOperationsCommon::OnSnoozedAlarmsCountChange callback)
            -> void;
        auto handleAddActiveAlarmCountChangeCallback(AlarmOperationsCommon::OnActiveAlarmCountChange callback) -> void;
        auto handleToggleAll(AlarmToggleAllRequestMessage *request) -> std::shared_ptr<AlarmToggleAllResponseMessage>;
        auto handleGetSnoozedAlarms(GetSnoozedAlarmsRequestMessage *request)
            -> std::shared_ptr<GetSnoozedAlarmsResponseMessage>;
        auto handleBatteryStateChange(sevm::BatteryStateChangeMessage *request) -> void;
        auto handleTurnOffPreWakeUp(TurnOffPreWakeUpRequestMessage *request)
            -> std::shared_ptr<TurnOffPreWakeUpResponseMessage>;

      private:
        stm::ServiceTime *service = nullptr;
        std::unique_ptr<IAlarmOperations> alarmOperations;

        template <class RequestType, class ResponseType, class CallbackParamType>
        auto handleWithCallback(RequestType *request,
                                const std::function<void(RequestType *request, std::function<void(CallbackParamType)>)>
                                    &alarmOperationsCallback) -> std::shared_ptr<ResponseType>;
    };
} // namespace alarms