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
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/ipc_helpers.h"
#include "core/hle/service/psc/time/common.h"
#include "core/hle/service/server_manager.h"
#include "core/hle/service/service.h"
namespace Core {
class System;
}
namespace Kernel {
class KSharedMemory;
}
namespace Service::PSC::Time {
class TimeManager;
class StandardLocalSystemClockCore;
class StandardUserSystemClockCore;
class StandardNetworkSystemClockCore;
class TimeZone;
class SystemClock;
class SteadyClock;
class TimeZoneService;
class EphemeralNetworkSystemClockCore;
class SharedMemory;
class StaticService final : public ServiceFramework<StaticService> {
using InClockSnapshot = InLargeData<ClockSnapshot, BufferAttr_HipcPointer>;
using OutClockSnapshot = OutLargeData<ClockSnapshot, BufferAttr_HipcPointer>;
public:
explicit StaticService(Core::System& system, StaticServiceSetupInfo setup_info,
std::shared_ptr<TimeManager> time, const char* name);
~StaticService() override = default;
Result GetStandardUserSystemClock(OutInterface<SystemClock> out_service);
Result GetStandardNetworkSystemClock(OutInterface<SystemClock> out_service);
Result GetStandardSteadyClock(OutInterface<SteadyClock> out_service);
Result GetTimeZoneService(OutInterface<TimeZoneService> out_service);
Result GetStandardLocalSystemClock(OutInterface<SystemClock> out_service);
Result GetEphemeralNetworkSystemClock(OutInterface<SystemClock> out_service);
Result GetSharedMemoryNativeHandle(OutCopyHandle<Kernel::KSharedMemory> out_shared_memory);
Result SetStandardSteadyClockInternalOffset(s64 offset_ns);
Result GetStandardSteadyClockRtcValue(Out<s64> out_rtc_value);
Result IsStandardUserSystemClockAutomaticCorrectionEnabled(Out<bool> out_is_enabled);
Result SetStandardUserSystemClockAutomaticCorrectionEnabled(bool automatic_correction);
Result GetStandardUserSystemClockInitialYear(Out<s32> out_year);
Result IsStandardNetworkSystemClockAccuracySufficient(Out<bool> out_is_sufficient);
Result GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(
Out<SteadyClockTimePoint> out_time_point);
Result CalculateMonotonicSystemClockBaseTimePoint(Out<s64> out_time,
const SystemClockContext& context);
Result GetClockSnapshot(OutClockSnapshot out_snapshot, TimeType type);
Result GetClockSnapshotFromSystemClockContext(TimeType type, OutClockSnapshot out_snapshot,
const SystemClockContext& user_context,
const SystemClockContext& network_context);
Result CalculateStandardUserSystemClockDifferenceByUser(Out<s64> out_difference,
InClockSnapshot a, InClockSnapshot b);
Result CalculateSpanBetween(Out<s64> out_time, InClockSnapshot a, InClockSnapshot b);
private:
Result GetClockSnapshotImpl(OutClockSnapshot out_snapshot,
const SystemClockContext& user_context,
const SystemClockContext& network_context, TimeType type);
Core::System& m_system;
StaticServiceSetupInfo m_setup_info;
std::shared_ptr<TimeManager> m_time;
StandardLocalSystemClockCore& m_local_system_clock;
StandardUserSystemClockCore& m_user_system_clock;
StandardNetworkSystemClockCore& m_network_system_clock;
TimeZone& m_time_zone;
EphemeralNetworkSystemClockCore& m_ephemeral_network_clock;
SharedMemory& m_shared_memory;
};
} // namespace Service::PSC::Time
|
