weh
This commit is contained in:
parent
cd74075a2e
commit
350e3a13db
GPG key ID:
0FF5B8826803F895
3 changed files with 365 additions and 192 deletions
|
|
@ -32,6 +32,7 @@ Checks: >
|
|||
-readability-magic-numbers
|
||||
CheckOptions:
|
||||
cppcoreguidelines-avoid-do-while.IgnoreMacros: "true"
|
||||
readability-else-after-return.WarnOnUnfixable: false
|
||||
readability-identifier-naming.ClassCase: CamelCase
|
||||
readability-identifier-naming.EnumCase: CamelCase
|
||||
readability-identifier-naming.LocalConstantCase: camelBack
|
||||
|
|
|
|||
483
src/os/linux.cpp
483
src/os/linux.cpp
|
|
@ -5,7 +5,6 @@
|
|||
// clang-format on
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <ranges>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/statvfs.h>
|
||||
#include <sys/sysinfo.h>
|
||||
|
|
@ -18,57 +17,120 @@
|
|||
#include "os.h"
|
||||
#include "src/os/linux/display_guards.h"
|
||||
#include "src/util/macros.h"
|
||||
#include "src/util/types.h"
|
||||
|
||||
using namespace std::string_view_literals;
|
||||
|
||||
namespace {
|
||||
fn GetX11WindowManager() -> Option<String> {
|
||||
fn MakeOsErrorFromDBus(const DBus::Error& err) -> OsError {
|
||||
String name = err.name();
|
||||
|
||||
if (name == "org.freedesktop.DBus.Error.ServiceUnknown" || name == "org.freedesktop.DBus.Error.NameHasNoOwner")
|
||||
return OsError { OsErrorCode::NotFound, std::format("DBus service/name not found: {}", err.message()) };
|
||||
|
||||
if (name == "org.freedesktop.DBus.Error.NoReply" || name == "org.freedesktop.DBus.Error.Timeout")
|
||||
return OsError { OsErrorCode::Timeout, std::format("DBus timeout/no reply: {}", err.message()) };
|
||||
|
||||
if (name == "org.freedesktop.DBus.Error.AccessDenied")
|
||||
return OsError { OsErrorCode::PermissionDenied, std::format("DBus access denied: {}", err.message()) };
|
||||
|
||||
return OsError { OsErrorCode::PlatformSpecific, std::format("DBus error: {} - {}", name, err.message()) };
|
||||
}
|
||||
|
||||
fn MakeOsErrorFromErrno(const String& context = "") -> OsError {
|
||||
const i32 errNo = errno;
|
||||
const String msg = std::system_category().message(errNo);
|
||||
const String fullMsg = context.empty() ? msg : std::format("{}: {}", context, msg);
|
||||
|
||||
switch (errNo) {
|
||||
case EACCES:
|
||||
case EPERM: return OsError { OsErrorCode::PermissionDenied, fullMsg };
|
||||
case ENOENT: return OsError { OsErrorCode::NotFound, fullMsg };
|
||||
case ETIMEDOUT: return OsError { OsErrorCode::Timeout, fullMsg };
|
||||
case ENOTSUP: return OsError { OsErrorCode::NotSupported, fullMsg };
|
||||
case EIO: return OsError { OsErrorCode::IoError, fullMsg };
|
||||
case ECONNREFUSED:
|
||||
case ENETDOWN:
|
||||
case ENETUNREACH: return OsError { OsErrorCode::NetworkError, fullMsg };
|
||||
default: return OsError { OsErrorCode::PlatformSpecific, fullMsg };
|
||||
}
|
||||
}
|
||||
|
||||
fn GetX11WindowManager() -> Result<String, OsError> {
|
||||
using os::linux::XcbReplyGuard;
|
||||
using os::linux::XorgDisplayGuard;
|
||||
|
||||
const XorgDisplayGuard conn;
|
||||
|
||||
if (!conn)
|
||||
RETURN_ERR("Failed to open X11 display");
|
||||
if (const i32 err = xcb_connection_has_error(conn.get()); !conn || err != 0)
|
||||
return Err(
|
||||
OsError {
|
||||
OsErrorCode::ApiUnavailable,
|
||||
[&] -> String {
|
||||
switch (err) {
|
||||
case 0: return "Connection object invalid, but no specific XCB error code";
|
||||
case XCB_CONN_ERROR: return "Stream/Socket/Pipe Error";
|
||||
case XCB_CONN_CLOSED_EXT_NOTSUPPORTED: return "Closed: Extension Not Supported";
|
||||
case XCB_CONN_CLOSED_MEM_INSUFFICIENT: return "Closed: Insufficient Memory";
|
||||
case XCB_CONN_CLOSED_REQ_LEN_EXCEED: return "Closed: Request Length Exceeded";
|
||||
case XCB_CONN_CLOSED_PARSE_ERR: return "Closed: Display String Parse Error";
|
||||
case XCB_CONN_CLOSED_INVALID_SCREEN: return "Closed: Invalid Screen";
|
||||
case XCB_CONN_CLOSED_FDPASSING_FAILED: return "Closed: FD Passing Failed";
|
||||
default: return std::format("Unknown Error Code ({})", err);
|
||||
}
|
||||
}(),
|
||||
}
|
||||
);
|
||||
|
||||
fn internAtom = [&conn](const StringView name) -> XcbReplyGuard<xcb_intern_atom_reply_t> {
|
||||
const auto cookie = xcb_intern_atom(conn.get(), 0, static_cast<uint16_t>(name.size()), name.data());
|
||||
return XcbReplyGuard(xcb_intern_atom_reply(conn.get(), cookie, nullptr));
|
||||
fn internAtom = [&conn](const StringView name) -> Result<xcb_atom_t, OsError> {
|
||||
const XcbReplyGuard<xcb_intern_atom_reply_t> reply(xcb_intern_atom_reply(
|
||||
conn.get(), xcb_intern_atom(conn.get(), 0, static_cast<uint16_t>(name.size()), name.data()), nullptr
|
||||
));
|
||||
|
||||
if (!reply)
|
||||
return Err(
|
||||
OsError { OsErrorCode::PlatformSpecific, std::format("Failed to get X11 atom reply for '{}'", name) }
|
||||
);
|
||||
|
||||
return reply->atom;
|
||||
};
|
||||
|
||||
const XcbReplyGuard<xcb_intern_atom_reply_t> supportingWmCheck = internAtom("_NET_SUPPORTING_WM_CHECK");
|
||||
const XcbReplyGuard<xcb_intern_atom_reply_t> wmName = internAtom("_NET_WM_NAME");
|
||||
const XcbReplyGuard<xcb_intern_atom_reply_t> utf8String = internAtom("UTF8_STRING");
|
||||
const Result<xcb_atom_t, OsError> supportingWmCheckAtom = internAtom("_NET_SUPPORTING_WM_CHECK");
|
||||
const Result<xcb_atom_t, OsError> wmNameAtom = internAtom("_NET_WM_NAME");
|
||||
const Result<xcb_atom_t, OsError> utf8StringAtom = internAtom("UTF8_STRING");
|
||||
|
||||
if (!supportingWmCheck || !wmName || !utf8String)
|
||||
RETURN_ERR("Failed to get X11 atoms");
|
||||
if (!supportingWmCheckAtom || !wmNameAtom || !utf8StringAtom) {
|
||||
if (!supportingWmCheckAtom)
|
||||
ERROR_LOG("Failed to get _NET_SUPPORTING_WM_CHECK atom");
|
||||
|
||||
if (!wmNameAtom)
|
||||
ERROR_LOG("Failed to get _NET_WM_NAME atom");
|
||||
|
||||
if (!utf8StringAtom)
|
||||
ERROR_LOG("Failed to get UTF8_STRING atom");
|
||||
|
||||
return Err(OsError { OsErrorCode::PlatformSpecific, "Failed to get X11 atoms" });
|
||||
}
|
||||
|
||||
const XcbReplyGuard<xcb_get_property_reply_t> wmWindowReply(xcb_get_property_reply(
|
||||
conn.get(),
|
||||
xcb_get_property(conn.get(), 0, conn.rootScreen()->root, supportingWmCheck->atom, XCB_ATOM_WINDOW, 0, 1),
|
||||
xcb_get_property(conn.get(), 0, conn.rootScreen()->root, *supportingWmCheckAtom, XCB_ATOM_WINDOW, 0, 1),
|
||||
nullptr
|
||||
));
|
||||
|
||||
if (!wmWindowReply || wmWindowReply->type != XCB_ATOM_WINDOW || wmWindowReply->format != 32 ||
|
||||
xcb_get_property_value_length(wmWindowReply.get()) == 0)
|
||||
RETURN_ERR("Failed to get _NET_SUPPORTING_WM_CHECK property");
|
||||
return Err(OsError { OsErrorCode::NotFound, "Failed to get _NET_SUPPORTING_WM_CHECK property" });
|
||||
|
||||
const xcb_window_t wmRootWindow = *static_cast<xcb_window_t*>(xcb_get_property_value(wmWindowReply.get()));
|
||||
|
||||
const XcbReplyGuard<xcb_get_property_reply_t> wmNameReply(xcb_get_property_reply(
|
||||
conn.get(),
|
||||
xcb_get_property(
|
||||
conn.get(),
|
||||
0,
|
||||
*static_cast<xcb_window_t*>(xcb_get_property_value(wmWindowReply.get())),
|
||||
wmName->atom,
|
||||
utf8String->atom,
|
||||
0,
|
||||
1024
|
||||
),
|
||||
nullptr
|
||||
conn.get(), xcb_get_property(conn.get(), 0, wmRootWindow, *wmNameAtom, *utf8StringAtom, 0, 1024), nullptr
|
||||
));
|
||||
|
||||
if (!wmNameReply || wmNameReply->type != utf8String->atom || xcb_get_property_value_length(wmNameReply.get()) == 0)
|
||||
RETURN_ERR("Failed to get _NET_WM_NAME property");
|
||||
if (!wmNameReply || wmNameReply->type != *utf8StringAtom || xcb_get_property_value_length(wmNameReply.get()) == 0)
|
||||
return Err(OsError { OsErrorCode::NotFound, "Failed to get _NET_WM_NAME property" });
|
||||
|
||||
const char* nameData = static_cast<const char*>(xcb_get_property_value(wmNameReply.get()));
|
||||
const usize length = xcb_get_property_value_length(wmNameReply.get());
|
||||
|
|
@ -76,30 +138,30 @@ namespace {
|
|||
return String(nameData, length);
|
||||
}
|
||||
|
||||
fn GetWaylandCompositor() -> Option<String> {
|
||||
fn GetWaylandCompositor() -> Result<String, OsError> {
|
||||
using os::linux::WaylandDisplayGuard;
|
||||
|
||||
const WaylandDisplayGuard display;
|
||||
|
||||
if (!display)
|
||||
RETURN_ERR("Failed to open Wayland display");
|
||||
return Err(OsError { OsErrorCode::NotFound, "Failed to connect to display (is Wayland running?)" });
|
||||
|
||||
const i32 fileDescriptor = display.fd();
|
||||
if (fileDescriptor < 0)
|
||||
RETURN_ERR("Failed to get Wayland file descriptor");
|
||||
return Err(OsError { OsErrorCode::ApiUnavailable, "Failed to get Wayland file descriptor" });
|
||||
|
||||
ucred cred;
|
||||
socklen_t len = sizeof(cred);
|
||||
|
||||
if (getsockopt(fileDescriptor, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1)
|
||||
RETURN_ERR("Failed to get socket credentials: {}", std::error_code(errno, std::generic_category()).message());
|
||||
return Err(MakeOsErrorFromErrno("Failed to get socket credentials (SO_PEERCRED)"));
|
||||
|
||||
Array<char, 128> exeLinkPathBuf;
|
||||
|
||||
auto [out, size] = std::format_to_n(exeLinkPathBuf.data(), exeLinkPathBuf.size() - 1, "/proc/{}/exe", cred.pid);
|
||||
|
||||
if (out >= exeLinkPathBuf.data() + exeLinkPathBuf.size() - 1)
|
||||
RETURN_ERR("Failed to format /proc path (PID too large?)");
|
||||
return Err(OsError { OsErrorCode::InternalError, "Failed to format /proc path (PID too large?)" });
|
||||
|
||||
*out = '\0';
|
||||
|
||||
|
|
@ -110,26 +172,30 @@ namespace {
|
|||
const isize bytesRead = readlink(exeLinkPath, exeRealPathBuf.data(), exeRealPathBuf.size() - 1);
|
||||
|
||||
if (bytesRead == -1)
|
||||
RETURN_ERR("Failed to read link {}: {}", exeLinkPath, std::error_code(errno, std::generic_category()).message());
|
||||
return Err(MakeOsErrorFromErrno(std::format("Failed to read link '{}'", exeLinkPath)));
|
||||
|
||||
exeRealPathBuf.at(bytesRead) = '\0';
|
||||
|
||||
String compositorName;
|
||||
StringView compositorNameView;
|
||||
|
||||
try {
|
||||
namespace fs = std::filesystem;
|
||||
const StringView pathView(exeRealPathBuf.data(), bytesRead);
|
||||
|
||||
const fs::path exePath(exeRealPathBuf.data());
|
||||
StringView filenameView;
|
||||
|
||||
compositorName = exePath.filename().string();
|
||||
} catch (const std::filesystem::filesystem_error& e) {
|
||||
RETURN_ERR("Error getting compositor name from path '{}': {}", exeRealPathBuf.data(), e.what());
|
||||
} catch (...) { RETURN_ERR("Unknown error getting compositor name"); }
|
||||
if (const usize lastCharPos = pathView.find_last_not_of('/'); lastCharPos != StringView::npos) {
|
||||
const StringView relevantPart = pathView.substr(0, lastCharPos + 1);
|
||||
|
||||
if (compositorName.empty() || compositorName == "." || compositorName == "/")
|
||||
RETURN_ERR("Empty or invalid compositor name {}", compositorName);
|
||||
if (const usize separatorPos = relevantPart.find_last_of('/'); separatorPos == StringView::npos)
|
||||
filenameView = relevantPart;
|
||||
else
|
||||
filenameView = relevantPart.substr(separatorPos + 1);
|
||||
}
|
||||
|
||||
const StringView compositorNameView = compositorName;
|
||||
if (!filenameView.empty())
|
||||
compositorNameView = filenameView;
|
||||
|
||||
if (compositorNameView.empty() || compositorNameView == "." || compositorNameView == "/")
|
||||
return Err(OsError { OsErrorCode::NotFound, "Failed to get compositor name from path" });
|
||||
|
||||
if (constexpr StringView wrappedSuffix = "-wrapped"; compositorNameView.length() > 1 + wrappedSuffix.length() &&
|
||||
compositorNameView[0] == '.' && compositorNameView.ends_with(wrappedSuffix)) {
|
||||
|
|
@ -137,158 +203,212 @@ namespace {
|
|||
compositorNameView.substr(1, compositorNameView.length() - 1 - wrappedSuffix.length());
|
||||
|
||||
if (cleanedView.empty())
|
||||
RETURN_ERR("Compositor name invalid after heuristic: original='%s'\n", compositorName.c_str());
|
||||
return Err(OsError { OsErrorCode::NotFound, "Compositor name invalid after heuristic" });
|
||||
|
||||
return String(cleanedView);
|
||||
}
|
||||
|
||||
return compositorName;
|
||||
return String(compositorNameView);
|
||||
}
|
||||
|
||||
fn GetMprisPlayers(const SharedPointer<DBus::Connection>& connection) -> Result<Vec<String>, NowPlayingError> {
|
||||
fn GetMprisPlayers(const SharedPointer<DBus::Connection>& connection) -> Result<String, OsError> {
|
||||
try {
|
||||
const SharedPointer<DBus::CallMessage> call =
|
||||
DBus::CallMessage::create("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames");
|
||||
|
||||
const SharedPointer<DBus::Message> reply = connection->send_with_reply_blocking(call, 500);
|
||||
const SharedPointer<DBus::Message> reply = connection->send_with_reply_blocking(call, 5);
|
||||
|
||||
if (!reply) {
|
||||
ERROR_LOG("DBus timeout or null reply in ListNames");
|
||||
return Err("DBus timeout in ListNames");
|
||||
}
|
||||
if (!reply || !reply->is_valid())
|
||||
return Err(OsError { OsErrorCode::Timeout, "Failed to get reply from ListNames" });
|
||||
|
||||
Vec<String> allNamesStd;
|
||||
DBus::MessageIterator reader(*reply);
|
||||
reader >> allNamesStd;
|
||||
|
||||
Vec<String> mprisPlayers;
|
||||
for (const String& name : allNamesStd)
|
||||
if (StringView(name).contains("org.mpris.MediaPlayer2"sv))
|
||||
mprisPlayers.emplace_back(name);
|
||||
return name;
|
||||
|
||||
return mprisPlayers;
|
||||
} catch (const DBus::Error& e) {
|
||||
ERROR_LOG("DBus::Error exception in ListNames: {}", e.what());
|
||||
return Err(e.what());
|
||||
} catch (const Exception& e) {
|
||||
ERROR_LOG("Standard exception getting MPRIS players: {}", e.what());
|
||||
return Err(e.what());
|
||||
return Err(OsError { OsErrorCode::NotFound, "No MPRIS players found" });
|
||||
} catch (const DBus::Error& e) { return Err(MakeOsErrorFromDBus(e)); } catch (const Exception& e) {
|
||||
return Err(OsError { OsErrorCode::InternalError, e.what() });
|
||||
}
|
||||
}
|
||||
|
||||
fn GetMediaPlayerMetadata(const SharedPointer<DBus::Connection>& connection, const String& playerBusName)
|
||||
-> Result<MediaInfo, OsError> {
|
||||
try {
|
||||
const SharedPointer<DBus::CallMessage> metadataCall =
|
||||
DBus::CallMessage::create(playerBusName, "/org/mpris/MediaPlayer2", "org.freedesktop.DBus.Properties", "Get");
|
||||
|
||||
*metadataCall << "org.mpris.MediaPlayer2.Player" << "Metadata";
|
||||
|
||||
const SharedPointer<DBus::Message> metadataReply = connection->send_with_reply_blocking(metadataCall, 1000);
|
||||
|
||||
if (!metadataReply || !metadataReply->is_valid()) {
|
||||
return Err(OsError { OsErrorCode::Timeout, "DBus Get Metadata call timed out or received invalid reply" });
|
||||
}
|
||||
|
||||
DBus::MessageIterator iter(*metadataReply);
|
||||
DBus::Variant metadataVariant;
|
||||
iter >> metadataVariant; // Can throw
|
||||
|
||||
// MPRIS metadata is variant containing a dict a{sv}
|
||||
if (metadataVariant.type() != DBus::DataType::DICT_ENTRY && metadataVariant.type() != DBus::DataType::ARRAY) {
|
||||
return Err(
|
||||
OsError {
|
||||
OsErrorCode::ParseError,
|
||||
std::format(
|
||||
"Inner metadata variant is not the expected type, expected dict/a{{sv}} but got '{}'",
|
||||
metadataVariant.signature().str()
|
||||
),
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
Map<String, DBus::Variant> metadata = metadataVariant.to_map<String, DBus::Variant>(); // Can throw
|
||||
|
||||
Option<String> title = None;
|
||||
Option<String> artist = None;
|
||||
Option<String> album = None;
|
||||
Option<String> appName = None; // Try to get app name too
|
||||
|
||||
if (auto titleIter = metadata.find("xesam:title");
|
||||
titleIter != metadata.end() && titleIter->second.type() == DBus::DataType::STRING)
|
||||
title = titleIter->second.to_string();
|
||||
|
||||
if (auto artistIter = metadata.find("xesam:artist"); artistIter != metadata.end()) {
|
||||
if (artistIter->second.type() == DBus::DataType::ARRAY) {
|
||||
if (Vec<String> artists = artistIter->second.to_vector<String>(); !artists.empty())
|
||||
artist = artists[0];
|
||||
} else if (artistIter->second.type() == DBus::DataType::STRING) {
|
||||
artist = artistIter->second.to_string();
|
||||
}
|
||||
}
|
||||
|
||||
if (auto albumIter = metadata.find("xesam:album");
|
||||
albumIter != metadata.end() && albumIter->second.type() == DBus::DataType::STRING)
|
||||
album = albumIter->second.to_string();
|
||||
|
||||
try {
|
||||
const SharedPointer<DBus::CallMessage> identityCall =
|
||||
DBus::CallMessage::create(playerBusName, "/org/mpris/MediaPlayer2", "org.freedesktop.DBus.Properties", "Get");
|
||||
*identityCall << "org.mpris.MediaPlayer2" << "Identity";
|
||||
if (const SharedPointer<DBus::Message> identityReply = connection->send_with_reply_blocking(identityCall, 500);
|
||||
identityReply && identityReply->is_valid()) {
|
||||
DBus::MessageIterator identityIter(*identityReply);
|
||||
DBus::Variant identityVariant;
|
||||
identityIter >> identityVariant;
|
||||
if (identityVariant.type() == DBus::DataType::STRING)
|
||||
appName = identityVariant.to_string();
|
||||
}
|
||||
} catch (const DBus::Error& e) {
|
||||
DEBUG_LOG("Failed to get player Identity property for {}: {}", playerBusName, e.what()); // Non-fatal
|
||||
}
|
||||
|
||||
return MediaInfo(std::move(title), std::move(artist), std::move(album), std::move(appName));
|
||||
} catch (const DBus::Error& e) { return Err(MakeOsErrorFromDBus(e)); } catch (const Exception& e) {
|
||||
return Err(
|
||||
OsError { OsErrorCode::InternalError, std::format("Standard exception processing metadata: {}", e.what()) }
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn os::GetOSVersion() -> Result<String, String> {
|
||||
fn os::GetOSVersion() -> Result<String, OsError> {
|
||||
constexpr CStr path = "/etc/os-release";
|
||||
|
||||
std::ifstream file(path);
|
||||
|
||||
if (!file)
|
||||
return Err(std::format("Failed to open {}", path));
|
||||
return Err(OsError { OsErrorCode::NotFound, std::format("Failed to open {}", path) });
|
||||
|
||||
String line;
|
||||
const String prefix = "PRETTY_NAME=";
|
||||
String line;
|
||||
constexpr StringView prefix = "PRETTY_NAME=";
|
||||
|
||||
while (getline(file, line))
|
||||
if (line.starts_with(prefix)) {
|
||||
StringView valueView = StringView(line).substr(prefix.size());
|
||||
while (getline(file, line)) {
|
||||
if (StringView(line).starts_with(prefix)) {
|
||||
String value = line.substr(prefix.size());
|
||||
|
||||
if (!valueView.empty() && valueView.front() == '"' && valueView.back() == '"') {
|
||||
valueView.remove_prefix(1);
|
||||
valueView.remove_suffix(1);
|
||||
}
|
||||
if ((value.length() >= 2 && value.front() == '"' && value.back() == '"') ||
|
||||
(value.length() >= 2 && value.front() == '\'' && value.back() == '\''))
|
||||
value = value.substr(1, value.length() - 2);
|
||||
|
||||
return String(valueView);
|
||||
if (value.empty())
|
||||
return Err(
|
||||
OsError { OsErrorCode::ParseError, std::format("PRETTY_NAME value is empty or only quotes in {}", path) }
|
||||
);
|
||||
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
return Err(std::format("PRETTY_NAME line not found in {}", path));
|
||||
return Err(OsError { OsErrorCode::NotFound, std::format("PRETTY_NAME line not found in {}", path) });
|
||||
}
|
||||
|
||||
fn os::GetMemInfo() -> Result<u64, String> {
|
||||
fn os::GetMemInfo() -> Result<u64, OsError> {
|
||||
struct sysinfo info;
|
||||
|
||||
if (sysinfo(&info) != 0)
|
||||
return Err(std::format("sysinfo failed: {}", std::error_code(errno, std::generic_category()).message()));
|
||||
return Err(MakeOsErrorFromErrno("sysinfo call failed"));
|
||||
|
||||
const u64 totalRam = info.totalram;
|
||||
const u64 memUnit = info.mem_unit;
|
||||
|
||||
if (memUnit == 0)
|
||||
return Err(OsError { OsErrorCode::InternalError, "sysinfo returned mem_unit of zero" });
|
||||
|
||||
if (totalRam > std::numeric_limits<u64>::max() / memUnit)
|
||||
return Err(OsError { OsErrorCode::InternalError, "Potential overflow calculating total RAM" });
|
||||
|
||||
return info.totalram * info.mem_unit;
|
||||
}
|
||||
|
||||
fn os::GetNowPlaying() -> Result<String, NowPlayingError> {
|
||||
try {
|
||||
const SharedPointer<DBus::Dispatcher> dispatcher = DBus::StandaloneDispatcher::create();
|
||||
if (!dispatcher)
|
||||
return Err("Failed to create DBus dispatcher");
|
||||
fn os::GetNowPlaying() -> Result<MediaInfo, NowPlayingError> {
|
||||
// Dispatcher must outlive the try-block because 'connection' depends on it later.
|
||||
// ReSharper disable once CppTooWideScope, CppJoinDeclarationAndAssignment
|
||||
SharedPointer<DBus::Dispatcher> dispatcher;
|
||||
SharedPointer<DBus::Connection> connection;
|
||||
|
||||
const SharedPointer<DBus::Connection> connection = dispatcher->create_connection(DBus::BusType::SESSION);
|
||||
try {
|
||||
dispatcher = DBus::StandaloneDispatcher::create();
|
||||
|
||||
if (!dispatcher)
|
||||
return Err(OsError { OsErrorCode::ApiUnavailable, "Failed to create DBus dispatcher" });
|
||||
|
||||
connection = dispatcher->create_connection(DBus::BusType::SESSION);
|
||||
|
||||
if (!connection)
|
||||
return Err("Failed to connect to session bus");
|
||||
|
||||
Result<Vec<String>, NowPlayingError> mprisPlayersResult = GetMprisPlayers(connection);
|
||||
if (!mprisPlayersResult)
|
||||
return Err(mprisPlayersResult.error());
|
||||
|
||||
const Vec<String>& mprisPlayers = *mprisPlayersResult;
|
||||
|
||||
if (mprisPlayers.empty())
|
||||
return Err(NowPlayingCode::NoPlayers);
|
||||
|
||||
const String activePlayer = mprisPlayers.front();
|
||||
|
||||
const SharedPointer<DBus::CallMessage> metadataCall =
|
||||
DBus::CallMessage::create(activePlayer, "/org/mpris/MediaPlayer2", "org.freedesktop.DBus.Properties", "Get");
|
||||
|
||||
*metadataCall << "org.mpris.MediaPlayer2.Player" << "Metadata";
|
||||
|
||||
const SharedPointer<DBus::Message> metadataReply = connection->send_with_reply_blocking(metadataCall, 5000);
|
||||
|
||||
String title;
|
||||
String artist;
|
||||
|
||||
if (metadataReply && metadataReply->is_valid()) {
|
||||
try {
|
||||
DBus::MessageIterator iter(*metadataReply);
|
||||
DBus::Variant metadataVariant;
|
||||
iter >> metadataVariant;
|
||||
|
||||
if (metadataVariant.type() == DBus::DataType::ARRAY) {
|
||||
Map<String, DBus::Variant> metadata = metadataVariant.to_map<String, DBus::Variant>();
|
||||
|
||||
if (auto titleIter = metadata.find("xesam:title");
|
||||
titleIter != metadata.end() && titleIter->second.type() == DBus::DataType::STRING)
|
||||
title = titleIter->second.to_string();
|
||||
|
||||
if (auto artistIter = metadata.find("xesam:artist"); artistIter != metadata.end()) {
|
||||
if (artistIter->second.type() == DBus::DataType::ARRAY) {
|
||||
if (Vec<String> artists = artistIter->second.to_vector<String>(); !artists.empty())
|
||||
artist = artists[0];
|
||||
} else if (artistIter->second.type() == DBus::DataType::STRING)
|
||||
artist = artistIter->second.to_string();
|
||||
}
|
||||
} else {
|
||||
ERROR_LOG(
|
||||
"Metadata variant is not the expected type, expected a{{sv}} but got {}", metadataVariant.signature().str()
|
||||
);
|
||||
}
|
||||
} catch (const DBus::Error& e) {
|
||||
ERROR_LOG("DBus error processing metadata reply: {}", e.what());
|
||||
} catch (const Exception& e) { ERROR_LOG("Error processing metadata reply: {}", e.what()); }
|
||||
}
|
||||
|
||||
return std::format("{}{}{}", artist, !artist.empty() && !title.empty() ? " - " : "", title);
|
||||
} catch (const DBus::Error& e) { return Err(std::format("DBus error: {}", e.what())); } catch (const Exception& e) {
|
||||
return Err(std::format("General error: {}", e.what()));
|
||||
return Err(OsError { OsErrorCode::ApiUnavailable, "Failed to connect to DBus session bus" });
|
||||
} catch (const DBus::Error& e) { return Err(MakeOsErrorFromDBus(e)); } catch (const Exception& e) {
|
||||
return Err(OsError { OsErrorCode::InternalError, e.what() });
|
||||
}
|
||||
|
||||
Result<String, NowPlayingError> playerBusName = GetMprisPlayers(connection);
|
||||
|
||||
if (!playerBusName)
|
||||
return Err(playerBusName.error());
|
||||
|
||||
Result<MediaInfo, OsError> metadataResult = GetMediaPlayerMetadata(connection, *playerBusName);
|
||||
|
||||
if (!metadataResult)
|
||||
return Err(metadataResult.error());
|
||||
|
||||
return std::move(*metadataResult);
|
||||
}
|
||||
|
||||
fn os::GetWindowManager() -> Option<String> {
|
||||
// clang-format off
|
||||
return GetWaylandCompositor()
|
||||
.or_else([] { return GetX11WindowManager(); })
|
||||
.and_then([](const String& windowManager) -> Option<String> {
|
||||
DEBUG_LOG("Found window manager: {}", windowManager);
|
||||
return windowManager;
|
||||
});
|
||||
// clang-format on
|
||||
if (Result<String, OsError> waylandResult = GetWaylandCompositor())
|
||||
return *waylandResult;
|
||||
else
|
||||
DEBUG_LOG("Could not detect Wayland compositor: {}", waylandResult.error().message);
|
||||
|
||||
if (Result<String, OsError> x11Result = GetX11WindowManager())
|
||||
return *x11Result;
|
||||
else
|
||||
DEBUG_LOG("Could not detect X11 window manager: {}", x11Result.error().message);
|
||||
|
||||
return None;
|
||||
}
|
||||
|
||||
fn os::GetDesktopEnvironment() -> Option<String> {
|
||||
|
|
@ -307,7 +427,7 @@ fn os::GetDesktopEnvironment() -> Option<String> {
|
|||
.value_or(None);
|
||||
}
|
||||
|
||||
fn os::GetShell() -> String {
|
||||
fn os::GetShell() -> Option<String> {
|
||||
if (const Result<String, EnvError> shellPath = GetEnv("SHELL")) {
|
||||
// clang-format off
|
||||
constexpr Array<Pair<StringView, StringView>, 5> shellMap {{
|
||||
|
|
@ -326,51 +446,68 @@ fn os::GetShell() -> String {
|
|||
return *shellPath; // fallback to the raw shell path
|
||||
}
|
||||
|
||||
return "";
|
||||
return None;
|
||||
}
|
||||
|
||||
fn os::GetHost() -> String {
|
||||
constexpr CStr path = "/sys/class/dmi/id/product_family";
|
||||
fn os::GetHost() -> Result<String, OsError> {
|
||||
constexpr CStr primaryPath = "/sys/class/dmi/id/product_family";
|
||||
constexpr CStr fallbackPath = "/sys/class/dmi/id/product_name";
|
||||
|
||||
std::ifstream file(path);
|
||||
fn readFirstLine = [&](const String& path) -> Result<String, OsError> {
|
||||
std::ifstream file(path);
|
||||
String line;
|
||||
|
||||
if (!file) {
|
||||
ERROR_LOG("Failed to open {}", path);
|
||||
return "";
|
||||
}
|
||||
if (!file)
|
||||
return Err(
|
||||
OsError { OsErrorCode::NotFound, std::format("Failed to open DMI product identifier file '{}'", path) }
|
||||
);
|
||||
|
||||
String productFamily;
|
||||
if (!getline(file, line))
|
||||
return Err(OsError { OsErrorCode::ParseError, std::format("DMI product identifier file ('{}') is empty", path) });
|
||||
|
||||
if (!getline(file, productFamily)) {
|
||||
ERROR_LOG("Failed to read from {} (is it empty?)", path);
|
||||
return "";
|
||||
}
|
||||
return line;
|
||||
};
|
||||
|
||||
return productFamily;
|
||||
return readFirstLine(primaryPath).or_else([&](const OsError& primaryError) -> Result<String, OsError> {
|
||||
return readFirstLine(fallbackPath).or_else([&](const OsError& fallbackError) -> Result<String, OsError> {
|
||||
return Err(
|
||||
OsError {
|
||||
OsErrorCode::InternalError,
|
||||
std::format(
|
||||
"Failed to get host identifier. Primary ('{}'): {}. Fallback ('{}'): {}",
|
||||
primaryPath,
|
||||
primaryError.message,
|
||||
fallbackPath,
|
||||
fallbackError.message
|
||||
),
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
fn os::GetKernelVersion() -> String {
|
||||
fn os::GetKernelVersion() -> Result<String, OsError> {
|
||||
utsname uts;
|
||||
|
||||
if (uname(&uts) == -1) {
|
||||
ERROR_LOG("uname() failed: {}", std::error_code(errno, std::generic_category()).message());
|
||||
return "";
|
||||
}
|
||||
if (uname(&uts) == -1)
|
||||
return Err(MakeOsErrorFromErrno("uname call failed"));
|
||||
|
||||
if (strlen(uts.release) == 0)
|
||||
return Err(OsError { OsErrorCode::ParseError, "uname returned null kernel release" });
|
||||
|
||||
return uts.release;
|
||||
}
|
||||
|
||||
fn os::GetDiskUsage() -> Pair<u64, u64> {
|
||||
fn os::GetDiskUsage() -> Result<DiskSpace, OsError> {
|
||||
struct statvfs stat;
|
||||
|
||||
if (statvfs("/", &stat) == -1) {
|
||||
ERROR_LOG("statvfs() failed: {}", std::error_code(errno, std::generic_category()).message());
|
||||
return { 0, 0 };
|
||||
}
|
||||
if (statvfs("/", &stat) == -1)
|
||||
return Err(MakeOsErrorFromErrno(std::format("Failed to get filesystem stats for '/' (statvfs call failed)")));
|
||||
|
||||
// ReSharper disable CppRedundantParentheses
|
||||
return { (stat.f_blocks * stat.f_frsize) - (stat.f_bfree * stat.f_frsize), stat.f_blocks * stat.f_frsize };
|
||||
// ReSharper restore CppRedundantParentheses
|
||||
return DiskSpace {
|
||||
.used_bytes = (stat.f_blocks * stat.f_frsize) - (stat.f_bfree * stat.f_frsize),
|
||||
.total_bytes = stat.f_blocks * stat.f_frsize,
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -159,19 +159,18 @@ enum class NowPlayingCode : u8 {
|
|||
* @brief Error codes for general OS-level operations.
|
||||
*/
|
||||
enum class OsErrorCode : u8 {
|
||||
ApiUnavailable, ///< An underlying OS API failed, is unavailable, or returned an error.
|
||||
BufferTooSmall, ///< A pre-allocated buffer was insufficient (less common with dynamic allocation).
|
||||
InternalError, ///< An unspecified internal error within the abstraction layer.
|
||||
IoError, ///< A general input/output error occurred.
|
||||
NetworkError, ///< Network-related error (relevant if OS functions involve network).
|
||||
NotFound, ///< A required resource (file, registry key, device) was not found.
|
||||
NotSupported, ///< The requested operation is not supported on this platform or configuration.
|
||||
ParseError, ///< Failed to parse data obtained from the OS (e.g., file content, API output).
|
||||
IoError, ///< General I/O error (filesystem, pipes, etc.).
|
||||
PermissionDenied, ///< Insufficient permissions to perform the operation.
|
||||
PlatformSpecific, ///< An error specific to the platform occurred (check message for details).
|
||||
Success, ///< Operation completed successfully (often implicit).
|
||||
Timeout, ///< An operation timed out (e.g., waiting for DBus reply).
|
||||
Other, ///< A generic error code for unclassified errors.
|
||||
NotFound, ///< A required resource (file, registry key, device, API endpoint) was not found.
|
||||
ParseError, ///< Failed to parse data obtained from the OS (e.g., file content, API output).
|
||||
ApiUnavailable, ///< A required OS service/API is unavailable or failed unexpectedly at runtime.
|
||||
NotSupported, ///< The requested operation is not supported on this platform, version, or configuration.
|
||||
Timeout, ///< An operation timed out (e.g., waiting for IPC reply).
|
||||
BufferTooSmall, ///< Optional: Keep if using fixed C-style buffers, otherwise remove.
|
||||
InternalError, ///< An error occurred within the application's OS abstraction code logic.
|
||||
NetworkError, ///< A network-related error occurred (e.g., DNS resolution, connection failure).
|
||||
PlatformSpecific, ///< An unmapped error specific to the underlying OS platform occurred (check message).
|
||||
Other, ///< A generic or unclassified error originating from the OS or an external library.
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -186,15 +185,51 @@ struct OsError {
|
|||
|
||||
OsError(const OsErrorCode errc, String msg) : message(std::move(msg)), code(errc) {}
|
||||
|
||||
explicit OsError(const Exception& e) : message(e.what()) {}
|
||||
explicit OsError(const Exception& exc) : message(exc.what()) {}
|
||||
|
||||
explicit OsError(const std::error_code& errc) : message(errc.message()) {
|
||||
using enum OsErrorCode;
|
||||
using enum std::errc;
|
||||
|
||||
switch (static_cast<std::errc>(errc.value())) {
|
||||
case permission_denied: code = PermissionDenied; break;
|
||||
case no_such_file_or_directory: code = NotFound; break;
|
||||
case timed_out: code = Timeout; break;
|
||||
case io_error: code = IoError; break;
|
||||
case network_unreachable:
|
||||
case network_down:
|
||||
case connection_refused: code = NetworkError; break;
|
||||
case not_supported: code = NotSupported; break;
|
||||
default: code = errc.category() == std::generic_category() ? InternalError : PlatformSpecific; break;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
explicit OsError(const winrt::hresult_error& e)
|
||||
: message(winrt::to_string(e.message())), code(OsErrorCode::PlatformSpecific) {}
|
||||
#endif
|
||||
: message(winrt::to_string(e.message())) /*, original_code(e.code()) */ {
|
||||
switch (e.code()) {
|
||||
case E_ACCESSDENIED: code = OsErrorCode::PermissionDenied; break;
|
||||
case HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND):
|
||||
case HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND):
|
||||
case HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_FOUND): code = OsErrorCode::NotFound; break;
|
||||
case HRESULT_FROM_WIN32(ERROR_TIMEOUT):
|
||||
case HRESULT_FROM_WIN32(ERROR_SEM_TIMEOUT): code = OsErrorCode::Timeout; break;
|
||||
case HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED): code = OsErrorCode::NotSupported; break;
|
||||
default: code = OsErrorCode::PlatformSpecific; break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
OsError(OsErrorCode code_hint, int errno_val) : message(std::system_category().message(errno_val)), code(code_hint) {
|
||||
using enum OsErrorCode;
|
||||
|
||||
#ifndef _WIN32
|
||||
OsError(OsErrorCode c, int errno_val) : code(c), message(std::system_category().message(errno_val)) {}
|
||||
switch (errno_val) {
|
||||
case EACCES: code = PermissionDenied; break;
|
||||
case ENOENT: code = NotFound; break;
|
||||
case ETIMEDOUT: code = Timeout; break;
|
||||
case ENOTSUP: code = NotSupported; break;
|
||||
default: code = PlatformSpecific; break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -229,8 +264,8 @@ struct MediaInfo {
|
|||
Option<String> app_name; ///< Name of the media player application (e.g., "Spotify", "Firefox").
|
||||
PlaybackStatus status = PlaybackStatus::Unknown; ///< Current playback status.
|
||||
|
||||
MediaInfo(Option<String> t, Option<String> a, Option<String> al, Option<String> app)
|
||||
: title(std::move(t)), artist(std::move(a)), album(std::move(al)), app_name(std::move(app)) {}
|
||||
MediaInfo(Option<String> title, Option<String> artist, Option<String> album, Option<String> app)
|
||||
: title(std::move(title)), artist(std::move(artist)), album(std::move(album)), app_name(std::move(app)) {}
|
||||
};
|
||||
|
||||
//--------------------------------------------------------//
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue