// Copyright (c) 2017-2024, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/blob/master/LICENSE.md
#include "ServiceTime.hpp"
#include "service-evtmgr/EVMessages.hpp"
#include <service-time/internal/StaticData.hpp>
#include <service-time/RTCCommand.hpp>
#include <service-time/TimeMessage.hpp>
#include <service-time/TimeSettings.hpp>
#include <service-time/TimezoneHandler.hpp>
#include <service-audio/AudioServiceName.hpp>
#include <service-audio/AudioMessage.hpp>
#include <service-cellular/ServiceCellular.hpp>
#include <time/TimeZone.hpp>
#include <service-db/agents/settings/SystemSettings.hpp>
namespace stm
{
namespace
{
constexpr auto serviceTimeStackDepth = 1024 * 16;
constexpr auto automaticTimezoneName = "";
constexpr auto automaticTimezoneRules = "UTC0";
} // namespace
ServiceTime::ServiceTime(std::shared_ptr<alarms::IAlarmOperationsFactory> alarmOperationsFactory)
: sys::Service(service::name::service_time, "", serviceTimeStackDepth),
timeManager{std::make_unique<TimeManager>(std::make_unique<RTCCommand>(this))},
alarmOperationsFactory{std::move(alarmOperationsFactory)}
{
bus.channels.push_back(sys::BusChannel::ServiceDBNotifications);
bus.channels.push_back(sys::BusChannel::ServiceEvtmgrNotifications);
}
ServiceTime::~ServiceTime()
{}
sys::ReturnCodes ServiceTime::InitHandler()
{
settings = std::make_unique<settings::Settings>();
settings->init(::service::ServiceProxy(shared_from_this()));
initStaticData();
static TimeSettings timeSettings;
utils::time::TimestampFactory().init(&timeSettings);
auto alarmEventsRepo = std::make_unique<alarms::AlarmEventsDBRepository>(this);
auto alarmOperations = alarmOperationsFactory->create(this, std::move(alarmEventsRepo), TimePointNow);
alarmOperations->updateEventsCache(TimePointNow());
alarmOperations->addCheckIfPhoneCallIsOngoingCallback([this]() -> bool {
bool isPhoneCallInProgress = false;
// Check Call state in Cellular
if (!CellularServiceAPI::IsCallInProgress(this, isPhoneCallInProgress)) {
LOG_ERROR("Unable to check if the Call is in progress for Cellular service");
}
// Double check is ApplicationCall (if App exist) has active state of call
if (!isPhoneCallInProgress &&
!CellularServiceAPI::IsCallStateForCallApplicationActive(this, isPhoneCallInProgress)) {
LOG_WARN("Unable to check if the ApplicationCall has Active Call State. "
"Call Status not considered active");
}
return isPhoneCallInProgress;
});
alarmOperations->addAlarmDuringPhoneCallCallback(
[this]() { this->bus.sendUnicast(std::make_shared<SingleVibrationStart>(), service::name::audio); });
alarmMessageHandler = std::make_unique<alarms::AlarmMessageHandler>(this, std::move(alarmOperations));
registerMessageHandlers();
LOG_INFO("Initialized");
return sys::ReturnCodes::Success;
}
sys::ReturnCodes ServiceTime::DeinitHandler()
{
settings->deinit();
LOG_INFO("Deinitialized");
return sys::ReturnCodes::Success;
}
sys::ReturnCodes ServiceTime::SwitchPowerModeHandler(const sys::ServicePowerMode mode)
{
return sys::ReturnCodes::Success;
}
sys::MessagePointer ServiceTime::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
{
if (resp != nullptr && resp->responseTo == MessageType::DBQuery) {
if (auto queryResponse = dynamic_cast<db::QueryResponse *>(resp)) {
auto result = queryResponse->getResult();
if (result != nullptr) {
if (result->hasListener()) {
result->handle();
}
}
}
}
if (msgl->messageType == MessageType::EVMMinuteUpdated) {
alarmMessageHandler->handleMinuteUpdated();
return std::make_shared<sys::ResponseMessage>();
}
else if (msgl->messageType == MessageType::EVMTimeUpdated) {
alarmMessageHandler->handleTimeUpdate(TimePointNow());
return std::make_shared<sys::ResponseMessage>();
}
return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
}
void ServiceTime::registerMessageHandlers()
{
connect(typeid(cellular::TimeNotificationMessage), [&](sys::Message *request) -> sys::MessagePointer {
return handleCellularTimeNotificationMessage(request);
});
connect(typeid(stm::message::SetAutomaticDateAndTimeRequest),
[&](sys::Message *request) -> sys::MessagePointer {
return handleSetAutomaticDateAndTimeRequest(request);
});
connect(typeid(stm::message::SetTimeFormatRequest),
[&](sys::Message *request) -> sys::MessagePointer { return handleSetTimeFormatRequest(request); });
connect(typeid(stm::message::SetDateFormatRequest),
[&](sys::Message *request) -> sys::MessagePointer { return handleSetDateFormatRequest(request); });
connect(typeid(stm::message::SetTimezoneRequest),
[&](sys::Message *request) -> sys::MessagePointer { return handleSetTimezoneRequest(request); });
connect(typeid(stm::message::TimeChangeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
auto message = static_cast<stm::message::TimeChangeRequestMessage *>(request);
timeManager->handleTimeChangeRequest(message->getTime());
return std::make_shared<sys::ResponseMessage>();
});
connect(typeid(stm::message::GetAutomaticDateAndTimeRequest),
[&](sys::Message *request) -> sys::MessagePointer { return handleGetAutomaticDateAndTimeRequest(); });
connect(typeid(alarms::AlarmGetRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleGetAlarm(static_cast<alarms::AlarmGetRequestMessage *>(request));
});
connect(typeid(alarms::AlarmGetWithStatusRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleGetAlarmWithStatus(
static_cast<alarms::AlarmGetWithStatusRequestMessage *>(request));
});
connect(typeid(alarms::AlarmAddRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleAddAlarm(static_cast<alarms::AlarmAddRequestMessage *>(request));
});
connect(typeid(alarms::AlarmUpdateRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleUpdateAlarm(static_cast<alarms::AlarmUpdateRequestMessage *>(request));
});
connect(typeid(alarms::AlarmRemoveRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleRemoveAlarm(static_cast<alarms::AlarmRemoveRequestMessage *>(request));
});
connect(typeid(alarms::AlarmToggleAllRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleToggleAll(static_cast<alarms::AlarmToggleAllRequestMessage *>(request));
});
connect(typeid(alarms::AlarmsGetInRangeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleGetAlarmsInRange(
static_cast<alarms::AlarmsGetInRangeRequestMessage *>(request));
});
connect(typeid(alarms::AlarmGetNextSingleEventsRequestMessage),
[&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleGetNextSingleEvents(
static_cast<alarms::AlarmGetNextSingleEventsRequestMessage *>(request));
});
connect(typeid(alarms::RingingAlarmTurnOffRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleTurnOffRingingAlarm(
static_cast<alarms::RingingAlarmTurnOffRequestMessage *>(request));
});
connect(typeid(alarms::TurnOffSnoozeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleTurnOffSnooze(
static_cast<alarms::TurnOffSnoozeRequestMessage *>(request));
});
connect(typeid(alarms::RingingAlarmSnoozeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleSnoozeRingingAlarm(
static_cast<alarms::RingingAlarmSnoozeRequestMessage *>(request));
});
connect(typeid(alarms::PostponeSnoozeRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handlePostponeSnooze(
static_cast<alarms::PostponeSnoozeRequestMessage *>(request));
});
connect(typeid(alarms::StopAllSnoozedAlarmsRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
alarmMessageHandler->handleStopAllSnoozedAlarms();
return std::make_shared<sys::ResponseMessage>();
});
connect(
typeid(alarms::RegisterSnoozedAlarmsCountChangeHandlerRequestMessage),
[&](sys::Message *request) -> sys::MessagePointer {
auto senderName = request->sender;
alarmMessageHandler->handleAddSnoozedAlarmCountChangeCallback([this, senderName](unsigned snoozeCount) {
bus.sendUnicast(std::make_shared<alarms::SnoozedAlarmsCountChangeMessage>(snoozeCount), senderName);
});
return std::make_shared<sys::ResponseMessage>();
});
connect(typeid(alarms::RegisterActiveAlarmsIndicatorHandlerRequestMessage),
[&](sys::Message *request) -> sys::MessagePointer {
auto senderName = request->sender;
alarmMessageHandler->handleAddActiveAlarmCountChangeCallback(
[this, senderName](bool isAnyAlarmActive) {
bus.sendUnicast(std::make_shared<alarms::ActiveAlarmMessage>(isAnyAlarmActive), senderName);
});
return std::make_shared<sys::ResponseMessage>();
});
connect(typeid(alarms::GetSnoozedAlarmsRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
auto message = static_cast<alarms::GetSnoozedAlarmsRequestMessage *>(request);
return alarmMessageHandler->handleGetSnoozedAlarms(message);
});
connect(typeid(sevm::BatteryStateChangeMessage), [&](sys::Message *request) -> sys::MessagePointer {
auto message = static_cast<sevm::BatteryStateChangeMessage *>(request);
alarmMessageHandler->handleBatteryStateChange(message);
return std::make_shared<sys::ResponseMessage>();
});
connect(typeid(alarms::TurnOffPreWakeUpRequestMessage), [&](sys::Message *request) -> sys::MessagePointer {
return alarmMessageHandler->handleTurnOffPreWakeUp(
static_cast<alarms::TurnOffPreWakeUpRequestMessage *>(request));
});
}
auto ServiceTime::handleSetAutomaticDateAndTimeRequest(sys::Message *request)
-> std::shared_ptr<sys::ResponseMessage>
{
auto message = static_cast<stm::message::SetAutomaticDateAndTimeRequest *>(request);
if (stm::api::isAutomaticDateAndTime() == message->getValue()) {
LOG_INFO("The selected automatic date and time value is already set, ignoring");
return std::shared_ptr<sys::ResponseMessage>();
}
settings->setValue(settings::SystemProperties::automaticDateAndTimeIsOn, std::to_string(message->getValue()));
stm::internal::StaticData::get().setAutomaticDateAndTime(message->getValue());
if (!stm::api::isAutomaticDateAndTime()) {
timeManager->handleTimezoneChangeRequest(automaticTimezoneRules);
settings->setValue(settings::SystemProperties::currentTimezoneRules, automaticTimezoneRules);
stm::internal::StaticData::get().setTimezoneRules(automaticTimezoneRules);
settings->setValue(settings::SystemProperties::currentTimezoneName, automaticTimezoneName);
stm::internal::StaticData::get().setTimezoneName(automaticTimezoneName);
}
bus.sendUnicast(std::make_shared<stm::message::AutomaticDateAndTimeChangedMessage>(message->getValue()),
service::name::cellular);
return std::shared_ptr<sys::ResponseMessage>();
}
auto ServiceTime::handleSetTimeFormatRequest(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
{
auto message = static_cast<stm::message::SetTimeFormatRequest *>(request);
if (stm::api::timeFormat() == message->getTimeFormat()) {
LOG_INFO("The selected time format value is already set, ignoring");
return std::shared_ptr<sys::ResponseMessage>();
}
settings->setValue(settings::SystemProperties::timeFormat,
std::to_string(static_cast<unsigned>(message->getTimeFormat())));
stm::internal::StaticData::get().setTimeFormat(message->getTimeFormat());
return std::shared_ptr<sys::ResponseMessage>();
}
auto ServiceTime::handleSetDateFormatRequest(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
{
auto message = static_cast<stm::message::SetDateFormatRequest *>(request);
if (stm::api::dateFormat() == message->getDateFormat()) {
LOG_INFO("The selected date format value is already set, ignoring");
return std::shared_ptr<sys::ResponseMessage>();
}
settings->setValue(settings::SystemProperties::dateFormat,
std::to_string(static_cast<unsigned>(message->getDateFormat())));
stm::internal::StaticData::get().setDateFormat(message->getDateFormat());
return std::shared_ptr<sys::ResponseMessage>();
}
auto ServiceTime::handleSetTimezoneRequest(sys::Message *request) -> std::shared_ptr<sys::ResponseMessage>
{
auto message = static_cast<stm::message::SetTimezoneRequest *>(request);
auto timeZoneName = message->getTimezoneName();
auto timeZoneRules = utils::time::getTimeZoneRules(timeZoneName);
timeManager->handleTimezoneChangeRequest(timeZoneRules);
settings->setValue(settings::SystemProperties::currentTimezoneName, timeZoneName);
stm::internal::StaticData::get().setTimezoneName(timeZoneName);
settings->setValue(settings::SystemProperties::currentTimezoneRules, timeZoneRules);
stm::internal::StaticData::get().setTimezoneRules(timeZoneRules);
return std::shared_ptr<sys::ResponseMessage>();
}
auto ServiceTime::handleCellularTimeNotificationMessage(sys::Message *request)
-> std::shared_ptr<sys::ResponseMessage>
{
auto message = static_cast<cellular::TimeNotificationMessage *>(request);
auto timezoneRules = TimezoneHandler(std::chrono::duration_cast<std::chrono::minutes>(
std::chrono::seconds{message->getTimeZoneOffset().value()}))
.getTimezone();
if (stm::api::isAutomaticDateAndTime()) {
timeManager->handleCellularTimeUpdate(message->getTime().value(), timezoneRules);
settings->setValue(settings::SystemProperties::currentTimezoneRules, timezoneRules);
stm::internal::StaticData::get().setTimezoneRules(timezoneRules);
settings->setValue(settings::SystemProperties::currentTimezoneName, automaticTimezoneName);
stm::internal::StaticData::get().setTimezoneName(automaticTimezoneName);
}
return std::make_shared<sys::ResponseMessage>();
}
void ServiceTime::initStaticData()
{
stm::internal::StaticData::get().setAutomaticDateAndTime(
utils::getNumericValue<bool>(settings->getValue(::settings::SystemProperties::automaticDateAndTimeIsOn)));
auto dateFormat = magic_enum::enum_cast<utils::time::Locale::DateFormat>(
utils::getNumericValue<int>(settings->getValue(::settings::SystemProperties::dateFormat)));
if (dateFormat != std::nullopt) {
stm::internal::StaticData::get().setDateFormat(dateFormat.value());
}
auto timeFormat = magic_enum::enum_cast<utils::time::Locale::TimeFormat>(
utils::getNumericValue<int>(settings->getValue(::settings::SystemProperties::timeFormat)));
if (timeFormat != std::nullopt) {
stm::internal::StaticData::get().setTimeFormat(timeFormat.value());
}
auto timezoneName =
settings->getValue(settings::SystemProperties::currentTimezoneName, settings::SettingsScope::AppLocal);
stm::internal::StaticData::get().setTimezoneName(timezoneName);
auto timezoneRules =
settings->getValue(settings::SystemProperties::currentTimezoneRules, settings::SettingsScope::AppLocal);
stm::internal::StaticData::get().setTimezoneRules(timezoneRules);
timeManager->handleTimezoneChangeRequest(timezoneRules);
}
auto ServiceTime::handleGetAutomaticDateAndTimeRequest() -> std::shared_ptr<sys::ResponseMessage>
{
return std::make_shared<stm::message::GetAutomaticDateAndTimeResponse>(stm::api::isAutomaticDateAndTime());
}
} // namespace stm