yuzu-qt: Track play time

src/common/fs/fs_paths.h

@@ -18,6 +18,7 @@
 #define LOAD_DIR "load"
 #define LOG_DIR "log"
 #define NAND_DIR "nand"
+#define PLAY_TIME_DIR "play_time"
 #define SCREENSHOTS_DIR "screenshots"
 #define SDMC_DIR "sdmc"
 #define SHADER_DIR "shader"

src/common/fs/path_util.cpp

@@ -122,6 +122,7 @@ public:
         GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
         GenerateYuzuPath(YuzuPath::LogDir, yuzu_path / LOG_DIR);
         GenerateYuzuPath(YuzuPath::NANDDir, yuzu_path / NAND_DIR);
+        GenerateYuzuPath(YuzuPath::PlayTimeDir, yuzu_path / PLAY_TIME_DIR);
         GenerateYuzuPath(YuzuPath::ScreenshotsDir, yuzu_path / SCREENSHOTS_DIR);
         GenerateYuzuPath(YuzuPath::SDMCDir, yuzu_path / SDMC_DIR);
         GenerateYuzuPath(YuzuPath::ShaderDir, yuzu_path / SHADER_DIR);

src/common/fs/path_util.h

@@ -20,6 +20,7 @@ enum class YuzuPath {
     LoadDir,        // Where cheat/mod files are stored.
     LogDir,         // Where log files are stored.
     NANDDir,        // Where the emulated NAND is stored.
+    PlayTimeDir,    // Where play time data is stored.
     ScreenshotsDir, // Where yuzu screenshots are stored.
     SDMCDir,        // Where the emulated SDMC is stored.
     ShaderDir,      // Where shaders are stored.

src/yuzu/CMakeLists.txt

@@ -195,6 +195,8 @@ add_executable(yuzu
     multiplayer/state.cpp
     multiplayer/state.h
     multiplayer/validation.h
+    play_time.cpp
+    play_time.h
     precompiled_headers.h
     qt_common.cpp
     qt_common.h

src/yuzu/configuration/configure_ui.cpp

@@ -126,6 +126,8 @@ ConfigureUi::ConfigureUi(Core::System& system_, QWidget* parent)
     connect(ui->show_compat, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
     connect(ui->show_size, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
     connect(ui->show_types, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
+    connect(ui->show_play_time, &QCheckBox::stateChanged, this,
+            &ConfigureUi::RequestGameListUpdate);
     connect(ui->game_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
             &ConfigureUi::RequestGameListUpdate);
     connect(ui->folder_icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged),
@@ -170,6 +172,7 @@ void ConfigureUi::ApplyConfiguration() {
     UISettings::values.show_compat = ui->show_compat->isChecked();
     UISettings::values.show_size = ui->show_size->isChecked();
     UISettings::values.show_types = ui->show_types->isChecked();
+    UISettings::values.show_play_time = ui->show_play_time->isChecked();
     UISettings::values.game_icon_size = ui->game_icon_size_combobox->currentData().toUInt();
     UISettings::values.folder_icon_size = ui->folder_icon_size_combobox->currentData().toUInt();
     UISettings::values.row_1_text_id = ui->row_1_text_combobox->currentData().toUInt();
@@ -182,6 +185,7 @@ void ConfigureUi::ApplyConfiguration() {
     const u32 height = ScreenshotDimensionToInt(ui->screenshot_height->currentText());
     UISettings::values.screenshot_height.SetValue(height);
 
+    RequestGameListUpdate();
     system.ApplySettings();
 }
 
@@ -197,6 +201,7 @@ void ConfigureUi::SetConfiguration() {
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());
     ui->show_types->setChecked(UISettings::values.show_types.GetValue());
+    ui->show_play_time->setChecked(UISettings::values.show_play_time.GetValue());
     ui->game_icon_size_combobox->setCurrentIndex(
         ui->game_icon_size_combobox->findData(UISettings::values.game_icon_size.GetValue()));
     ui->folder_icon_size_combobox->setCurrentIndex(

src/yuzu/configuration/configure_ui.ui

@@ -104,6 +104,13 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QCheckBox" name="show_play_time">
+          <property name="text">
+           <string>Show Play Time Column</string>
+          </property>
+         </widget>
+        </item>
         <item>
          <layout class="QHBoxLayout" name="game_icon_size_qhbox_layout_2">
           <item>

src/yuzu/game_list.cpp

@@ -340,6 +340,7 @@ GameList::GameList(FileSys::VirtualFilesystem vfs_, FileSys::ManualContentProvid
 
     tree_view->setColumnHidden(COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
     tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
+    tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
     item_model->setSortRole(GameListItemPath::SortRole);
 
     connect(main_window, &GMainWindow::UpdateThemedIcons, this, &GameList::OnUpdateThemedIcons);
@@ -548,6 +549,7 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     QAction* remove_update = remove_menu->addAction(tr("Remove Installed Update"));
     QAction* remove_dlc = remove_menu->addAction(tr("Remove All Installed DLC"));
     QAction* remove_custom_config = remove_menu->addAction(tr("Remove Custom Configuration"));
+    QAction* remove_play_time_data = remove_menu->addAction(tr("Remove Play Time Data"));
     QAction* remove_cache_storage = remove_menu->addAction(tr("Remove Cache Storage"));
     QAction* remove_gl_shader_cache = remove_menu->addAction(tr("Remove OpenGL Pipeline Cache"));
     QAction* remove_vk_shader_cache = remove_menu->addAction(tr("Remove Vulkan Pipeline Cache"));
@@ -619,6 +621,8 @@ void GameList::AddGamePopup(QMenu& context_menu, u64 program_id, const std::stri
     connect(remove_custom_config, &QAction::triggered, [this, program_id, path]() {
         emit RemoveFileRequested(program_id, GameListRemoveTarget::CustomConfiguration, path);
     });
+    connect(remove_play_time_data, &QAction::triggered,
+            [this, program_id]() { emit RemovePlayTimeRequested(program_id); });
     connect(remove_cache_storage, &QAction::triggered, [this, program_id, path] {
         emit RemoveFileRequested(program_id, GameListRemoveTarget::CacheStorage, path);
     });
@@ -785,6 +789,7 @@ void GameList::RetranslateUI() {
     item_model->setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
     item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
     item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    item_model->setHeaderData(COLUMN_PLAY_TIME, Qt::Horizontal, tr("Play time"));
 }
 
 void GameListSearchField::changeEvent(QEvent* event) {
@@ -812,6 +817,7 @@ void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
     tree_view->setColumnHidden(COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
     tree_view->setColumnHidden(COLUMN_FILE_TYPE, !UISettings::values.show_types);
     tree_view->setColumnHidden(COLUMN_SIZE, !UISettings::values.show_size);
+    tree_view->setColumnHidden(COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
 
     // Delete any rows that might already exist if we're repopulating
     item_model->removeRows(0, item_model->rowCount());

src/yuzu/game_list.h

@@ -74,6 +74,7 @@ public:
         COLUMN_ADD_ONS,
         COLUMN_FILE_TYPE,
         COLUMN_SIZE,
+        COLUMN_PLAY_TIME,
         COLUMN_COUNT, // Number of columns
     };
 
@@ -112,6 +113,7 @@ signals:
     void RemoveInstalledEntryRequested(u64 program_id, InstalledEntryType type);
     void RemoveFileRequested(u64 program_id, GameListRemoveTarget target,
                              const std::string& game_path);
+    void RemovePlayTimeRequested(u64 program_id);
     void DumpRomFSRequested(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
     void CopyTIDRequested(u64 program_id);
     void CreateShortcut(u64 program_id, const std::string& game_path,

src/yuzu/game_list_p.h

@@ -18,6 +18,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
+#include "yuzu/play_time.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/util.h"
 
@@ -221,6 +222,31 @@ public:
     }
 };
 
+/**
+ * GameListItem for Play Time values.
+ * This object stores the play time of a game in seconds, and its readable
+ * representation in minutes/hours
+ */
+class GameListItemPlayTime : public GameListItem {
+public:
+    static constexpr int PlayTimeRole = SortRole;
+
+    GameListItemPlayTime() = default;
+    explicit GameListItemPlayTime(const qulonglong time_seconds) {
+        setData(time_seconds, PlayTimeRole);
+    }
+
+    void setData(const QVariant& value, int role) override {
+        qulonglong time_seconds = value.toULongLong();
+        GameListItem::setData(PlayTime::ReadablePlayTime(time_seconds), Qt::DisplayRole);
+        GameListItem::setData(value, PlayTimeRole);
+    }
+
+    bool operator<(const QStandardItem& other) const override {
+        return data(PlayTimeRole).toULongLong() < other.data(PlayTimeRole).toULongLong();
+    }
+};
+
 class GameListDir : public GameListItem {
 public:
     static constexpr int GameDirRole = Qt::UserRole + 2;

src/yuzu/game_list_worker.cpp

@@ -27,6 +27,7 @@
 #include "yuzu/game_list.h"
 #include "yuzu/game_list_p.h"
 #include "yuzu/game_list_worker.h"
+#include "yuzu/play_time.h"
 #include "yuzu/uisettings.h"
 
 namespace {
@@ -212,6 +213,7 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path, const std::stri
         new GameListItemCompat(compatibility),
         new GameListItem(file_type_string),
         new GameListItemSize(size),
+        new GameListItemPlayTime(PlayTime::GetPlayTime(program_id)),
     };
 
     const auto patch_versions = GetGameListCachedObject(

src/yuzu/main.cpp

@@ -146,6 +146,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/install_dialog.h"
 #include "yuzu/loading_screen.h"
 #include "yuzu/main.h"
+#include "yuzu/play_time.h"
 #include "yuzu/startup_checks.h"
 #include "yuzu/uisettings.h"
 #include "yuzu/util/clickable_label.h"
@@ -334,6 +335,8 @@ GMainWindow::GMainWindow(std::unique_ptr<Config> config_, bool has_broken_vulkan
     SetDiscordEnabled(UISettings::values.enable_discord_presence.GetValue());
     discord_rpc->Update();
 
+    play_time_manager = std::make_unique<PlayTime::PlayTimeManager>();
+
     system->GetRoomNetwork().Init();
 
     RegisterMetaTypes();
@@ -1446,6 +1449,8 @@ void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::RemoveInstalledEntryRequested, this,
             &GMainWindow::OnGameListRemoveInstalledEntry);
     connect(game_list, &GameList::RemoveFileRequested, this, &GMainWindow::OnGameListRemoveFile);
+    connect(game_list, &GameList::RemovePlayTimeRequested, this,
+            &GMainWindow::OnGameListRemovePlayTimeData);
     connect(game_list, &GameList::DumpRomFSRequested, this, &GMainWindow::OnGameListDumpRomFS);
     connect(game_list, &GameList::CopyTIDRequested, this, &GMainWindow::OnGameListCopyTID);
     connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
@@ -2458,6 +2463,20 @@ void GMainWindow::OnGameListRemoveFile(u64 program_id, GameListRemoveTarget targ
     }
 }
 
+void GMainWindow::OnGameListRemovePlayTimeData(u64 program_id) {
+    if (QMessageBox::question(this, tr("Remove Play Time Data"), tr("Reset play time?"),
+                              QMessageBox::Yes | QMessageBox::No,
+                              QMessageBox::No) != QMessageBox::Yes) {
+        return;
+    }
+    if (!play_time_manager->ResetProgramPlayTime(program_id)) {
+        QMessageBox::warning(this, tr("Error Resetting Play Time Data"),
+                             tr("Play time couldn't be cleared"));
+        return;
+    }
+    game_list->PopulateAsync(UISettings::values.game_dirs);
+}
+
 void GMainWindow::RemoveTransferableShaderCache(u64 program_id, GameListRemoveTarget target) {
     const auto target_file_name = [target] {
         switch (target) {
@@ -3230,6 +3249,9 @@ void GMainWindow::OnStartGame() {
     UpdateMenuState();
     OnTasStateChanged();
 
+    play_time_manager->SetProgramId(system->GetApplicationProcessProgramID());
+    play_time_manager->Start();
+
     discord_rpc->Update();
 }
 
@@ -3245,6 +3267,7 @@ void GMainWindow::OnRestartGame() {
 
 void GMainWindow::OnPauseGame() {
     emu_thread->SetRunning(false);
+    play_time_manager->Stop();
     UpdateMenuState();
     AllowOSSleep();
 }
@@ -3265,6 +3288,9 @@ void GMainWindow::OnStopGame() {
         return;
     }
 
+    play_time_manager->Stop();
+    // Update game list to show new play time
+    game_list->PopulateAsync(UISettings::values.game_dirs);
     if (OnShutdownBegin()) {
         OnShutdownBeginDialog();
     } else {

src/yuzu/main.h

@@ -76,6 +76,10 @@ namespace DiscordRPC {
 class DiscordInterface;
 }
 
+namespace PlayTime {
+class PlayTimeManager;
+}
+
 namespace FileSys {
 class ContentProvider;
 class ManualContentProvider;
@@ -312,6 +316,7 @@ private slots:
     void OnGameListRemoveInstalledEntry(u64 program_id, InstalledEntryType type);
     void OnGameListRemoveFile(u64 program_id, GameListRemoveTarget target,
                               const std::string& game_path);
+    void OnGameListRemovePlayTimeData(u64 program_id);
     void OnGameListDumpRomFS(u64 program_id, const std::string& game_path, DumpRomFSTarget target);
     void OnGameListCopyTID(u64 program_id);
     void OnGameListNavigateToGamedbEntry(u64 program_id,
@@ -374,6 +379,7 @@ private:
     void RemoveVulkanDriverPipelineCache(u64 program_id);
     void RemoveAllTransferableShaderCaches(u64 program_id);
     void RemoveCustomConfiguration(u64 program_id, const std::string& game_path);
+    void RemovePlayTimeData(u64 program_id);
     void RemoveCacheStorage(u64 program_id);
     std::optional<u64> SelectRomFSDumpTarget(const FileSys::ContentProvider&, u64 program_id);
     InstallResult InstallNSPXCI(const QString& filename);
@@ -411,6 +417,7 @@ private:
 
     std::unique_ptr<Core::System> system;
     std::unique_ptr<DiscordRPC::DiscordInterface> discord_rpc;
+    std::unique_ptr<PlayTime::PlayTimeManager> play_time_manager;
     std::shared_ptr<InputCommon::InputSubsystem> input_subsystem;
 
     MultiplayerState* multiplayer_state = nullptr;

src/yuzu/play_time.cpp

@@ -0,0 +1,177 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/fs/file.h"
+#include "common/fs/path_util.h"
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "common/thread.h"
+#include "core/hle/service/acc/profile_manager.h"
+
+#include "yuzu/play_time.h"
+
+namespace PlayTime {
+
+void PlayTimeManager::SetProgramId(u64 program_id) {
+    this->running_program_id = program_id;
+}
+
+inline void PlayTimeManager::UpdateTimestamp() {
+    this->last_timestamp = std::chrono::steady_clock::now();
+}
+
+void PlayTimeManager::Start() {
+    UpdateTimestamp();
+    play_time_thread =
+        std::jthread([&](std::stop_token stop_token) { this->AutoTimestamp(stop_token); });
+}
+
+void PlayTimeManager::Stop() {
+    play_time_thread.request_stop();
+}
+
+void PlayTimeManager::AutoTimestamp(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("PlayTimeReport");
+
+    using namespace std::literals::chrono_literals;
+
+    const auto duration = 30s;
+    while (Common::StoppableTimedWait(stop_token, duration)) {
+        Save();
+    }
+
+    Save();
+}
+
+void PlayTimeManager::Save() {
+    const auto now = std::chrono::steady_clock::now();
+    const auto duration =
+        static_cast<u64>(std::chrono::duration_cast<std::chrono::seconds>(
+                             std::chrono::steady_clock::duration(now - this->last_timestamp))
+                             .count());
+    UpdateTimestamp();
+    if (!UpdatePlayTime(running_program_id, duration)) {
+        LOG_ERROR(Common, "Failed to update play time");
+    }
+}
+
+bool UpdatePlayTime(u64 program_id, u64 add_play_time) {
+    std::vector<PlayTimeElement> play_time_elements;
+    if (!ReadPlayTimeFile(play_time_elements)) {
+        return false;
+    }
+    const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
+
+    if (it == play_time_elements.end()) {
+        play_time_elements.push_back({.program_id = program_id, .play_time = add_play_time});
+    } else {
+        play_time_elements.at(it - play_time_elements.begin()).play_time += add_play_time;
+    }
+    if (!WritePlayTimeFile(play_time_elements)) {
+        return false;
+    }
+    return true;
+}
+
+u64 GetPlayTime(u64 program_id) {
+    std::vector<PlayTimeElement> play_time_elements;
+
+    if (!ReadPlayTimeFile(play_time_elements)) {
+        return 0;
+    }
+    const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
+    if (it == play_time_elements.end()) {
+        return 0;
+    }
+    return play_time_elements.at(it - play_time_elements.begin()).play_time;
+}
+
+bool PlayTimeManager::ResetProgramPlayTime(u64 program_id) {
+    std::vector<PlayTimeElement> play_time_elements;
+
+    if (!ReadPlayTimeFile(play_time_elements)) {
+        return false;
+    }
+    const auto it = std::find(play_time_elements.begin(), play_time_elements.end(), program_id);
+    if (it == play_time_elements.end()) {
+        return false;
+    }
+    play_time_elements.erase(it);
+    if (!WritePlayTimeFile(play_time_elements)) {
+        return false;
+    }
+    return true;
+}
+
+std::optional<std::filesystem::path> GetCurrentUserPlayTimePath() {
+    const Service::Account::ProfileManager manager;
+    const auto uuid = manager.GetUser(static_cast<s32>(Settings::values.current_user));
+    if (!uuid.has_value()) {
+        return std::nullopt;
+    }
+    return Common::FS::GetYuzuPath(Common::FS::YuzuPath::PlayTimeDir) /
+           uuid->RawString().append(".bin");
+}
+
+[[nodiscard]] bool ReadPlayTimeFile(std::vector<PlayTimeElement>& out_play_time_elements) {
+    const auto filename = GetCurrentUserPlayTimePath();
+    if (!filename.has_value()) {
+        LOG_ERROR(Common, "Failed to get current user path");
+        return false;
+    }
+
+    if (Common::FS::Exists(filename.value())) {
+        Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Read,
+                                Common::FS::FileType::BinaryFile};
+        if (!file.IsOpen()) {
+            LOG_ERROR(Common, "Failed to open play time file: {}",
+                      Common::FS::PathToUTF8String(filename.value()));
+            return false;
+        }
+        const size_t elem_num = file.GetSize() / sizeof(PlayTimeElement);
+        out_play_time_elements.resize(elem_num);
+        const bool success = file.ReadSpan<PlayTimeElement>(out_play_time_elements) == elem_num;
+        file.Close();
+        return success;
+    } else {
+        out_play_time_elements.clear();
+        return true;
+    }
+}
+
+[[nodiscard]] bool WritePlayTimeFile(const std::vector<PlayTimeElement>& play_time_elements) {
+    const auto filename = GetCurrentUserPlayTimePath();
+    if (!filename.has_value()) {
+        LOG_ERROR(Common, "Failed to get current user path");
+        return false;
+    }
+    Common::FS::IOFile file{filename.value(), Common::FS::FileAccessMode::Write,
+                            Common::FS::FileType::BinaryFile};
+
+    if (!file.IsOpen()) {
+        LOG_ERROR(Common, "Failed to open play time file: {}",
+                  Common::FS::PathToUTF8String(filename.value()));
+        return false;
+    }
+    const bool success =
+        file.WriteSpan<PlayTimeElement>(play_time_elements) == play_time_elements.size();
+    file.Close();
+    return success;
+}
+
+QString ReadablePlayTime(qulonglong time_seconds) {
+    static constexpr std::array units{"m", "h"};
+    if (time_seconds == 0) {
+        return QLatin1String("");
+    }
+    const auto time_minutes = std::max(static_cast<double>(time_seconds) / 60, 1.0);
+    const auto time_hours = static_cast<double>(time_seconds) / 3600;
+    const int unit = time_minutes < 60 ? 0 : 1;
+    const auto value = unit == 0 ? time_minutes : time_hours;
+
+    return QStringLiteral("%L1 %2")
+        .arg(value, 0, 'f', unit && time_seconds % 60 != 0)
+        .arg(QString::fromUtf8(units[unit]));
+}
+
+} // namespace PlayTime

src/yuzu/play_time.h

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QString>
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <optional>
+#include <thread>
+
+#include "common/common_types.h"
+#include "common/fs/fs.h"
+#include "common/polyfill_thread.h"
+#include "core/core.h"
+
+namespace PlayTime {
+struct PlayTimeElement {
+    u64 program_id;
+    u64 play_time;
+
+    inline bool operator==(const PlayTimeElement& other) const {
+        return program_id == other.program_id;
+    }
+
+    inline bool operator==(const u64 _program_id) const {
+        return program_id == _program_id;
+    }
+};
+
+class PlayTimeManager {
+public:
+    explicit PlayTimeManager() = default;
+    ~PlayTimeManager() = default;
+
+public:
+    YUZU_NON_COPYABLE(PlayTimeManager);
+    YUZU_NON_MOVEABLE(PlayTimeManager);
+
+public:
+    bool ResetProgramPlayTime(u64 program_id);
+    void SetProgramId(u64 program_id);
+    inline void UpdateTimestamp();
+    void Start();
+    void Stop();
+
+private:
+    u64 running_program_id;
+    std::chrono::steady_clock::time_point last_timestamp;
+    std::jthread play_time_thread;
+    void AutoTimestamp(std::stop_token stop_token);
+    void Save();
+};
+
+std::optional<std::filesystem::path> GetCurrentUserPlayTimePath();
+
+bool UpdatePlayTime(u64 program_id, u64 add_play_time);
+
+[[nodiscard]] bool ReadPlayTimeFile(std::vector<PlayTimeElement>& out_play_time_elements);
+[[nodiscard]] bool WritePlayTimeFile(const std::vector<PlayTimeElement>& play_time_elements);
+
+u64 GetPlayTime(u64 program_id);
+
+QString ReadablePlayTime(qulonglong time_seconds);
+
+} // namespace PlayTime

src/yuzu/uisettings.h

@@ -183,6 +183,9 @@ struct Values {
     Setting<bool> show_size{linkage, true, "show_size", Category::UiGameList};
     Setting<bool> show_types{linkage, true, "show_types", Category::UiGameList};
 
+    // Play time
+    Setting<bool> show_play_time{linkage, true, "show_play_time", Category::UiGameList};
+
     bool configuration_applied;
     bool reset_to_defaults;
     bool shortcut_already_warned{false};