diff --git a/.clang-format b/.clang-format index c3485b3..9fcdcf4 100644 --- a/.clang-format +++ b/.clang-format @@ -26,3 +26,4 @@ IncludeCategories: SpacesBeforeTrailingComments: 2 Cpp11BracedListStyle: true Standard: c++17 +NamespaceIndentation: All diff --git a/.gitignore b/.gitignore index 7275bfa..5c2b8e9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ .DS_Store .serena +.idea/ # Prerequisites *.d diff --git a/ISSUES/phase6-cleanup.md b/ISSUES/phase6-cleanup.md deleted file mode 100644 index b330732..0000000 --- a/ISSUES/phase6-cleanup.md +++ /dev/null @@ -1,115 +0,0 @@ -# Phase 6 cleanup — unfinished items - -Leftover from the architectural refactor. All items are small, contained, and build on -the already-present `Result` + RAII infrastructure. - -## Status - -| # | Item | File(s) | Status | -|---|------|---------|--------| -| 1 | `AccountProfileHandle` RAII + apply in `account.cpp` | `handles.hpp`, `account.cpp` | [x] | -| 2 | `FILE*` in `account.cpp::iconPath` → `FileHandle` | `account.cpp` | [x] | -| 3 | Split `io::restore` into three focused functions | `io.cpp`, `io.hpp` | [x] | -| 4 | `sendAll`/`recvAll` → `nxst::Result` | `transfer_service.cpp` | dropped — callers don't propagate error, `bool` is correct | - ---- - -## Item 1 — `AccountProfileHandle` RAII - -**File:** `include/nxst/infra/fs/handles.hpp` - -Add after `FileHandle`: - -```cpp -// RAII wrapper for AccountProfile — auto-closes on destruction. -struct AccountProfileHandle { - AccountProfile profile{}; - bool valid{false}; - - AccountProfileHandle() = default; - ~AccountProfileHandle() { - if (valid) - accountProfileClose(&profile); - } - AccountProfileHandle(const AccountProfileHandle&) = delete; - AccountProfileHandle& operator=(const AccountProfileHandle&) = delete; - - AccountProfile* get() { return &profile; } -}; -``` - -**Apply in `account.cpp`:** - -`getUser()` (line ~62): replace raw `AccountProfile profile` + manual `accountProfileClose` with `AccountProfileHandle`. - -`iconPath()` (line ~98): same — wrap `AccountProfile profile` → `AccountProfileHandle`. - ---- - -## Item 2 — `FILE*` in `iconPath` → `FileHandle` - -**File:** `src/domain/account.cpp`, lines ~115-119 - -```cpp -// before -FILE* f = fopen(path, "wb"); -if (!f) return ""; -fwrite(buf.data(), 1, outSize, f); -fclose(f); - -// after -nxst::FileHandle f(fopen(path, "wb")); -if (!f) return ""; -fwrite(buf.data(), 1, outSize, f.get()); -``` - -No `fclose` needed — `FileHandle` dtor handles it. - ---- - -## Item 3 — Split `io::restore` - -**Current:** `io.cpp:236-317` — one 80-line function doing mount, validate, clear, copy, commit. - -**Split into three `static` helpers in `io.cpp` (not exposed in header):** - -``` -static nxst::Result clearSaveRoot(const std::string& dst_path) - — removes all files/dirs under save:/ - -static nxst::Result extractAndCommit(const std::string& src_path, const std::string& dst_path) - — copyDirectory + fsdevCommitDevice - -io::restore (public) - — mount, validate src, call clearSaveRoot, call extractAndCommit, return success -``` - -`io.hpp` declaration unchanged — `io::restore` signature stays the same. - ---- - -## Item 4 — `sendAll`/`recvAll` → `nxst::Result` - -**File:** `src/service/transfer_service.cpp`, lines 32-55 - -```cpp -// before -static bool sendAll(int sock, const void* buf, size_t len) { ... return true/false; } -static bool recvAll(int sock, void* buf, size_t len) { ... return true/false; } - -// after -static nxst::Result sendAll(int sock, const void* buf, size_t len); -static nxst::Result recvAll(int sock, void* buf, size_t len); -``` - -All callers: `if (!sendAll(...))` → `if (!sendAll(...).isOk())`. - ---- - -## Verification - -``` -cmake --build build/ # must produce NXST.elf + NXST.nro with zero warnings -``` - -No observable behavior change — pure refactor. diff --git a/README.md b/README.md index 9c33eea..3b28446 100644 --- a/README.md +++ b/README.md @@ -39,8 +39,8 @@ Logs are written to `/switch/NXST/log.log`. **Prerequisites:** [devkitPro](https://devkitpro.org/wiki/Getting_Started) with `switch-dev` and `switch-portlibs` packages, plus `cmake ≥ 3.20`. ```bash -# Clone with submodules (Plutonium UI) -git clone --recurse-submodules https://github.com/your-username/NXST.git +# Clone (Plutonium UI fetched automatically by CMake) +git clone https://github.com/your-username/NXST.git cd NXST # Configure (once) diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index 896c863..83e737c 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -38,7 +38,7 @@ Sender polls in 100 ms slices for up to 3 seconds. Cancel is checked each slice. |-----------|-------| | Port | `8080` | | Direction | sender connects → receiver listens | -| Buffer size | 65 536 bytes (`proto::BUF_SIZE`) | +| Buffer size | 65 536 bytes (`proto::kBufSize`) | **Connection:** @@ -64,14 +64,14 @@ Sender polls in 100 ms slices for up to 3 seconds. Cancel is checked each slice. Files are sent sequentially. The stream ends with a sentinel frame: ``` -filename_len == 0 (proto::EOF_SENTINEL) +filename_len == 0 (proto::kEofSentinel) ``` No `filename` or `file_size` field follows the sentinel. **Constraints:** -- `filename_len > proto::MAX_FILENAME` (4 096) is treated as a protocol error; the receiver aborts. +- `filename_len > proto::kMaxFilename` (4 096) is treated as a protocol error; the receiver aborts. - Filenames are full paths as produced by `io::backup` (e.g. `/switch/NXST//<user>/...`). - On the receiver, the username path component is rewritten to match the local user's nickname before writing to disk. diff --git a/include/nxst/app/main.hpp b/include/nxst/app/main.hpp deleted file mode 100644 index c7337b9..0000000 --- a/include/nxst/app/main.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include <memory> - -#include <switch.h> - -#include <nxst/domain/account.hpp> -#include <nxst/domain/title.hpp> -#include <nxst/domain/util.hpp> -#include <nxst/infra/sys/logger.hpp> -#include <nxst/ui/const.h> - -typedef enum { SORT_ALPHA, SORT_LAST_PLAYED, SORT_PLAY_TIME, SORT_MODES_COUNT } sort_t; - -inline float g_currentTime = 0; -inline bool g_backupScrollEnabled = 0; -inline bool g_notificationLedAvailable = false; -inline bool g_shouldExitNetworkLoop = false; -inline std::string g_selectedCheatKey; -inline std::vector<std::string> g_selectedCheatCodes; -inline u32 g_username_dotsize; -inline sort_t g_sortMode = SORT_ALPHA; -inline std::string g_currentFile = ""; -inline bool g_isTransferringFile = false; -inline const std::string g_emptySave = "New..."; diff --git a/include/nxst/app/main_application.hpp b/include/nxst/app/main_application.hpp index 52ca05d..e3ebdce 100644 --- a/include/nxst/app/main_application.hpp +++ b/include/nxst/app/main_application.hpp @@ -8,16 +8,16 @@ namespace ui { -class MainApplication : public pu::ui::Application { + class MainApplication : public pu::ui::Application { - public: - using Application::Application; - PU_SMART_CTOR(MainApplication) + public: + using Application::Application; + PU_SMART_CTOR(MainApplication) - void OnLoad() override; + void OnLoad() override; - UsersLayout::Ref users_layout; - TitlesLayout::Ref titles_layout; - nxst::TransferService transfer; -}; + UsersLayout::Ref users_layout; + TitlesLayout::Ref titles_layout; + nxst::TransferService transfer; + }; } // namespace ui \ No newline at end of file diff --git a/include/nxst/domain/account.hpp b/include/nxst/domain/account.hpp index f3eda2e..ca7200a 100644 --- a/include/nxst/domain/account.hpp +++ b/include/nxst/domain/account.hpp @@ -1,59 +1,25 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once -#include <map> -#include <string.h> #include <string> #include <vector> #include <switch.h> -#define USER_ICON_SIZE 64 - +// Hash and comparison support for AccountUid as map/unordered_map key. namespace std { -template <> struct hash<AccountUid> { - size_t operator()(const AccountUid& a) const { - return ((hash<u64>()(a.uid[0]) ^ (hash<u64>()(a.uid[1]) << 1)) >> 1); - } -}; + template <> struct hash<AccountUid> { + size_t operator()(const AccountUid& a) const noexcept { + return (hash<u64>()(a.uid[0]) ^ (hash<u64>()(a.uid[1]) << 1)) >> 1; + } + }; } // namespace std inline bool operator==(const AccountUid& x, const AccountUid& y) { return x.uid[0] == y.uid[0] && x.uid[1] == y.uid[1]; } -inline bool operator==(const AccountUid& x, u64 y) { - return x.uid[0] == y && x.uid[1] == y; -} - inline bool operator<(const AccountUid& x, const AccountUid& y) { - if (x.uid[0] != y.uid[0]) - return x.uid[0] < y.uid[0]; - return x.uid[1] < y.uid[1]; + return x.uid[0] != y.uid[0] ? x.uid[0] < y.uid[0] : x.uid[1] < y.uid[1]; } struct User { @@ -61,12 +27,10 @@ struct User { std::string name; }; -namespace Account { -Result init(void); -void exit(void); - -std::vector<AccountUid> ids(void); -AccountUid selectAccount(void); -std::string username(AccountUid id); -std::string iconPath(AccountUid id); -} // namespace Account +namespace account { + Result init(); + void exit(); + std::vector<AccountUid> ids(); + std::string username(AccountUid id); + std::string iconPath(AccountUid id); +} // namespace account diff --git a/include/nxst/domain/common.hpp b/include/nxst/domain/common.hpp deleted file mode 100644 index 8bebd12..0000000 --- a/include/nxst/domain/common.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - -#pragma once -#include <algorithm> -#include <arpa/inet.h> -#include <codecvt> -#include <cstdio> -#include <locale> -#include <memory> -#include <netinet/in.h> -#include <stdarg.h> -#include <string.h> -#include <string> -#include <sys/socket.h> -#include <time.h> -#include <unistd.h> - -#define ATEXIT(func) atexit((void (*)())func) - -namespace DateTime { -std::string timeStr(void); -std::string dateTimeStr(void); -std::string logDateTime(void); -} // namespace DateTime - -namespace StringUtils { -bool containsInvalidChar(const std::string& str); -std::string escapeJson(const std::string& s); -std::string format(const std::string fmt_str, ...); -std::string removeForbiddenCharacters(std::string src); -std::string UTF16toUTF8(const std::u16string& src); -void ltrim(std::string& s); -void rtrim(std::string& s); -void trim(std::string& s); -} // namespace StringUtils - -char* getConsoleIP(void); diff --git a/include/nxst/domain/protocol.hpp b/include/nxst/domain/protocol.hpp index 245a777..adafb5d 100644 --- a/include/nxst/domain/protocol.hpp +++ b/include/nxst/domain/protocol.hpp @@ -1,17 +1,16 @@ #pragma once -#include <cstdint> namespace proto { -constexpr uint16_t TCP_PORT = 8080; -constexpr uint16_t MULTICAST_PORT = 8081; -constexpr char MULTICAST_GROUP[] = "239.0.0.1"; -constexpr size_t BUF_SIZE = 65536; -constexpr uint32_t MAX_FILENAME = 4096; -constexpr uint32_t EOF_SENTINEL = 0; + constexpr uint16_t kTcpPort = 8080; + constexpr uint16_t kMulticastPort = 8081; + constexpr char kMulticastGroup[] = "239.0.0.1"; + constexpr size_t kBufSize = 65536; + constexpr uint32_t kMaxFilename = 4096; + constexpr uint32_t kEofSentinel = 0; -// Wire layout per file: -// [filename_len : uint32_t LE] — 0 == end-of-stream -// [filename : filename_len bytes] -// [file_size : uint64_t LE] -// [file_data : file_size bytes] + // Wire layout per file: + // [filename_len : uint32_t LE] — 0 == end-of-stream + // [filename : filename_len bytes] + // [file_size : uint64_t LE] + // [file_data : file_size bytes] } // namespace proto diff --git a/include/nxst/domain/result.hpp b/include/nxst/domain/result.hpp index f146450..f92279d 100644 --- a/include/nxst/domain/result.hpp +++ b/include/nxst/domain/result.hpp @@ -4,105 +4,105 @@ namespace nxst { -template <class T, class E = std::string> class Result { - bool ok; - alignas(T) alignas(E) unsigned char storage[sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E)]; + template <class T, class E = std::string> class Result { + bool ok; + alignas(T) alignas(E) unsigned char storage[sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E)]; - Result() = default; + Result() = default; - public: - static Result success(T val) { - Result res; - res.ok = true; - new (res.storage) T(std::move(val)); - return res; - } + public: + static Result success(T val) { + Result res; + res.ok = true; + new (res.storage) T(std::move(val)); + return res; + } - static Result failure(E err) { - Result res; - res.ok = false; - new (res.storage) E(std::move(err)); - return res; - } + static Result failure(E err) { + Result res; + res.ok = false; + new (res.storage) E(std::move(err)); + return res; + } - ~Result() { - if (ok) - reinterpret_cast<T*>(storage)->~T(); - else - reinterpret_cast<E*>(storage)->~E(); - } + ~Result() { + if (ok) + reinterpret_cast<T*>(storage)->~T(); + else + reinterpret_cast<E*>(storage)->~E(); + } - Result(const Result& other) : ok(other.ok) { - if (ok) - new (storage) T(*reinterpret_cast<const T*>(other.storage)); - else - new (storage) E(*reinterpret_cast<const E*>(other.storage)); - } + Result(const Result& other) : ok(other.ok) { + if (ok) + new (storage) T(*reinterpret_cast<const T*>(other.storage)); + else + new (storage) E(*reinterpret_cast<const E*>(other.storage)); + } - Result(Result&& other) : ok(other.ok) { - if (ok) - new (storage) T(std::move(*reinterpret_cast<T*>(other.storage))); - else - new (storage) E(std::move(*reinterpret_cast<E*>(other.storage))); - } + Result(Result&& other) : ok(other.ok) { + if (ok) + new (storage) T(std::move(*reinterpret_cast<T*>(other.storage))); + else + new (storage) E(std::move(*reinterpret_cast<E*>(other.storage))); + } - Result& operator=(const Result&) = delete; + Result& operator=(const Result&) = delete; - bool isOk() const noexcept { - return ok; - } - const T& value() const { - return *reinterpret_cast<const T*>(storage); - } - const E& error() const { - return *reinterpret_cast<const E*>(storage); - } -}; + bool isOk() const noexcept { + return ok; + } + const T& value() const { + return *reinterpret_cast<const T*>(storage); + } + const E& error() const { + return *reinterpret_cast<const E*>(storage); + } + }; -// Specialisation for Result<void> -template <class E> class Result<void, E> { - bool ok; - alignas(E) unsigned char storage[sizeof(E)]; + // Specialisation for Result<void> + template <class E> class Result<void, E> { + bool ok; + alignas(E) unsigned char storage[sizeof(E)]; - Result() = default; + Result() = default; - public: - static Result success() { - Result res; - res.ok = true; - return res; - } + public: + static Result success() { + Result res; + res.ok = true; + return res; + } - static Result failure(E err) { - Result res; - res.ok = false; - new (res.storage) E(std::move(err)); - return res; - } + static Result failure(E err) { + Result res; + res.ok = false; + new (res.storage) E(std::move(err)); + return res; + } - ~Result() { - if (!ok) - reinterpret_cast<E*>(storage)->~E(); - } + ~Result() { + if (!ok) + reinterpret_cast<E*>(storage)->~E(); + } - Result(const Result& other) : ok(other.ok) { - if (!ok) - new (storage) E(*reinterpret_cast<const E*>(other.storage)); - } + Result(const Result& other) : ok(other.ok) { + if (!ok) + new (storage) E(*reinterpret_cast<const E*>(other.storage)); + } - Result(Result&& other) : ok(other.ok) { - if (!ok) - new (storage) E(std::move(*reinterpret_cast<E*>(other.storage))); - } + Result(Result&& other) : ok(other.ok) { + if (!ok) + new (storage) E(std::move(*reinterpret_cast<E*>(other.storage))); + } - Result& operator=(const Result&) = delete; + Result& operator=(const Result&) = delete; - bool isOk() const noexcept { - return ok; - } - const E& error() const { - return *reinterpret_cast<const E*>(storage); - } -}; + bool isOk() const noexcept { + return ok; + } + const E& error() const { + return *reinterpret_cast<const E*>(storage); + } + }; } // namespace nxst diff --git a/include/nxst/domain/title.hpp b/include/nxst/domain/title.hpp index 2a22410..7363451 100644 --- a/include/nxst/domain/title.hpp +++ b/include/nxst/domain/title.hpp @@ -1,32 +1,5 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once -#include <algorithm> -#include <stdlib.h> #include <string> #include <unordered_map> #include <utility> @@ -34,57 +7,52 @@ #include <switch.h> -#include <nxst/domain/account.hpp> -#include <nxst/infra/fs/filesystem.hpp> -#include <nxst/infra/fs/io.hpp> - class Title { public: - void init(u8 saveDataType, u64 titleid, AccountUid userID, const std::string& name, + void init(u8 save_data_type, u64 title_id, AccountUid uid, const std::string& name, const std::string& author); - ~Title() = default; - std::string author(void); - std::pair<std::string, std::string> displayName(void); - u64 id(void); - std::string name(void); - std::string path(void); - u64 playTimeNanoseconds(void); - std::string playTime(void); - void playTimeNanoseconds(u64 playTimeNanoseconds); - u32 lastPlayedTimestamp(void); - void lastPlayedTimestamp(u32 lastPlayedTimestamp); - std::string fullPath(size_t index); - void refreshDirectories(void); - u64 saveId(); + std::string author() const; + std::pair<std::string, std::string> displayName() const; + u64 id() const; + std::string name() const; + std::string path() const; + u64 playTimeNanoseconds() const; + std::string playTime() const; + void playTimeNanoseconds(u64 ns); + u32 lastPlayedTimestamp() const; + void lastPlayedTimestamp(u32 ts); + std::string fullPath(size_t index) const; + void refreshDirectories(); + u64 saveId() const; void saveId(u64 id); - std::vector<std::string> saves(void); - u8 saveDataType(void); - AccountUid userId(void); - std::string userName(void); + std::vector<std::string> saves() const; + u8 saveDataType() const; + AccountUid userId() const; + std::string userName() const; private: - u64 mId; - u64 mSaveId; - AccountUid mUserId; - std::string mUserName; - std::string mName; - std::string mSafeName; - std::string mAuthor; - std::string mPath; - std::vector<std::string> mSaves; - std::vector<std::string> mFullSavePaths; - u8 mSaveDataType; - std::pair<std::string, std::string> mDisplayName; - u64 mPlayTimeNanoseconds; - u32 mLastPlayedTimestamp; + u64 m_id{0}; + u64 m_save_id{0}; + AccountUid m_uid{}; + std::string m_user_name; + std::string m_name; + std::string m_safe_name; + std::string m_author; + std::string m_path; + std::vector<std::string> m_saves; + std::vector<std::string> m_full_save_paths; + u8 m_save_data_type{0}; + std::pair<std::string, std::string> m_display_name; + u64 m_play_time_ns{0}; + u32 m_last_played_ts{0}; }; +bool areTitlesLoaded(); +void loadTitles(); +void sortTitles(); +void rotateSortMode(); void getTitle(Title& dst, AccountUid uid, size_t i); size_t getTitleCount(AccountUid uid); -void loadTitles(void); -bool areTitlesLoaded(void); -void sortTitles(void); -void rotateSortMode(void); void refreshDirectories(u64 id); -std::unordered_map<std::string, std::string> getCompleteTitleList(void); +std::unordered_map<std::string, std::string> getCompleteTitleList(); diff --git a/include/nxst/domain/util.hpp b/include/nxst/domain/util.hpp index e9b4aa6..6642618 100644 --- a/include/nxst/domain/util.hpp +++ b/include/nxst/domain/util.hpp @@ -1,51 +1,22 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once -#include <sys/stat.h> #include <switch.h> -#include <nxst/domain/account.hpp> -#include <nxst/domain/common.hpp> -#include <nxst/infra/fs/io.hpp> - -// debug -#include <arpa/inet.h> -#include <sys/errno.h> -#include <sys/socket.h> - -void servicesExit(void); -Result servicesInit(void); -HidsysNotificationLedPattern blinkLedPattern(u8 times); +void servicesExit(); +Result servicesInit(); void blinkLed(u8 times); -namespace StringUtils { -std::string removeAccents(std::string str); -std::string removeNotAscii(std::string str); -std::u16string UTF8toUTF16(const char* src); -std::string elide(const std::string& s, size_t maxChars); -} // namespace StringUtils +namespace string_utils { + bool containsInvalidChar(const std::string& str); + std::string format(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + std::string removeForbiddenCharacters(std::string src); + std::string UTF16toUTF8(const std::u16string& src); + void ltrim(std::string& s); + void rtrim(std::string& s); + void trim(std::string& s); + std::string removeAccents(std::string str); + std::string removeNotAscii(std::string str); + std::u16string UTF8toUTF16(const char* src); + std::string elide(const std::string& s, size_t max_chars); +} // namespace string_utils diff --git a/include/nxst/infra/fs/directory.hpp b/include/nxst/infra/fs/directory.hpp index 826f4b0..a51d404 100644 --- a/include/nxst/infra/fs/directory.hpp +++ b/include/nxst/infra/fs/directory.hpp @@ -1,55 +1,32 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once -#include <dirent.h> -#include <errno.h> #include <string> #include <vector> #include <switch.h> -struct DirectoryEntry { - std::string name; - bool directory; -}; - class Directory { public: - Directory(const std::string& root); - ~Directory() = default; + explicit Directory(const std::string& path); - Result error(void); - std::string entry(size_t index); - bool folder(size_t index); - bool good(void); - size_t size(void); + bool good() const { + return m_good; + } + Result error() const { + return m_error; + } + size_t size() const { + return m_entries.size(); + } + std::string entry(size_t i) const; + bool folder(size_t i) const; private: - std::vector<struct DirectoryEntry> mList; - Result mError; - bool mGood; + struct Entry { + std::string name; + bool is_dir; + }; + std::vector<Entry> m_entries; + Result m_error{0}; + bool m_good{false}; }; diff --git a/include/nxst/infra/fs/filesystem.hpp b/include/nxst/infra/fs/filesystem.hpp index 77f3827..22eb421 100644 --- a/include/nxst/infra/fs/filesystem.hpp +++ b/include/nxst/infra/fs/filesystem.hpp @@ -1,36 +1,9 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once #include <switch.h> -#include <nxst/domain/account.hpp> - -namespace FileSystem { -Result mount(FsFileSystem* fileSystem, u64 titleID, AccountUid userID); -int mount(FsFileSystem fs); -void unmount(void); -} // namespace FileSystem +namespace file_system { + Result mount(FsFileSystem* fs, u64 title_id, AccountUid uid); + int mount(FsFileSystem fs); + void unmount(); +} // namespace file_system diff --git a/include/nxst/infra/fs/handles.hpp b/include/nxst/infra/fs/handles.hpp index ef8d1b8..ae41240 100644 --- a/include/nxst/infra/fs/handles.hpp +++ b/include/nxst/infra/fs/handles.hpp @@ -5,67 +5,67 @@ namespace nxst { -// RAII wrapper for FsFileSystem — auto-closes on destruction. -struct FsFileSystemHandle { - FsFileSystem fs{}; - bool valid{false}; + // RAII wrapper for FsFileSystem — auto-closes on destruction. + struct FsFileSystemHandle { + FsFileSystem fs{}; + bool valid{false}; - FsFileSystemHandle() = default; - ~FsFileSystemHandle() { - if (valid) - fsFsClose(&fs); - } // NOLINT(modernize-use-equals-default) + FsFileSystemHandle() = default; + ~FsFileSystemHandle() { + if (valid) + fsFsClose(&fs); + } // NOLINT(modernize-use-equals-default) - FsFileSystemHandle(const FsFileSystemHandle&) = delete; - FsFileSystemHandle& operator=(const FsFileSystemHandle&) = delete; + FsFileSystemHandle(const FsFileSystemHandle&) = delete; + FsFileSystemHandle& operator=(const FsFileSystemHandle&) = delete; - FsFileSystem* get() { - return &fs; - } + FsFileSystem* get() { + return &fs; + } - void release() { - valid = false; - } // transfer ownership to devfs -}; + void release() { + valid = false; + } // transfer ownership to devfs + }; -// RAII wrapper for FILE* — auto-fclose on destruction. -struct FileHandle { - FILE* ptr{nullptr}; + // RAII wrapper for FILE* — auto-fclose on destruction. + struct FileHandle { + FILE* ptr{nullptr}; - explicit FileHandle(FILE* file) : ptr(file) {} - ~FileHandle() { - if (ptr != nullptr) - fclose(ptr); - } // NOLINT(modernize-use-equals-default) + explicit FileHandle(FILE* file) : ptr(file) {} + ~FileHandle() { + if (ptr != nullptr) + fclose(ptr); + } // NOLINT(modernize-use-equals-default) - FileHandle(const FileHandle&) = delete; - FileHandle& operator=(const FileHandle&) = delete; + FileHandle(const FileHandle&) = delete; + FileHandle& operator=(const FileHandle&) = delete; - explicit operator bool() const { - return ptr != nullptr; - } - FILE* get() const { - return ptr; - } -}; + explicit operator bool() const { + return ptr != nullptr; + } + FILE* get() const { + return ptr; + } + }; -// RAII wrapper for AccountProfile — auto-closes on destruction. -struct AccountProfileHandle { - AccountProfile profile{}; - bool valid{false}; + // RAII wrapper for AccountProfile — auto-closes on destruction. + struct AccountProfileHandle { + AccountProfile profile{}; + bool valid{false}; - AccountProfileHandle() = default; - ~AccountProfileHandle() { - if (valid) - accountProfileClose(&profile); - } // NOLINT(modernize-use-equals-default) + AccountProfileHandle() = default; + ~AccountProfileHandle() { + if (valid) + accountProfileClose(&profile); + } // NOLINT(modernize-use-equals-default) - AccountProfileHandle(const AccountProfileHandle&) = delete; - AccountProfileHandle& operator=(const AccountProfileHandle&) = delete; + AccountProfileHandle(const AccountProfileHandle&) = delete; + AccountProfileHandle& operator=(const AccountProfileHandle&) = delete; - AccountProfile* get() { - return &profile; - } -}; + AccountProfile* get() { + return &profile; + } + }; } // namespace nxst diff --git a/include/nxst/infra/fs/io.hpp b/include/nxst/infra/fs/io.hpp index 920d73f..418f52d 100644 --- a/include/nxst/infra/fs/io.hpp +++ b/include/nxst/infra/fs/io.hpp @@ -1,53 +1,19 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #pragma once -#include <dirent.h> -#include <sys/stat.h> -#include <unistd.h> +#include <string> #include <switch.h> -#include <nxst/domain/account.hpp> #include <nxst/domain/result.hpp> -#include <nxst/domain/title.hpp> -#include <nxst/domain/util.hpp> -#include <nxst/infra/fs/directory.hpp> - -#define BUFFER_SIZE 0x80000 namespace io { -nxst::Result<std::string> backup(size_t index, AccountUid uid); -nxst::Result<std::string> restore(size_t index, AccountUid uid, size_t cellIndex, - const std::string& nameFromCell); + nxst::Result<std::string> backup(size_t index, AccountUid uid); + nxst::Result<std::string> restore(size_t index, AccountUid uid, const std::string& title_name); -Result copyDirectory(const std::string& srcPath, const std::string& dstPath); -void copyFile(const std::string& srcPath, const std::string& dstPath); -Result createDirectory(const std::string& path); -Result deleteFolderRecursively(const std::string& path); -bool directoryExists(const std::string& path); -bool fileExists(const std::string& path); + Result copyDirectory(const std::string& src, const std::string& dst); + void copyFile(const std::string& src, const std::string& dst); + Result createDirectory(const std::string& path); + Result deleteFolderRecursively(const std::string& path); + bool directoryExists(const std::string& path); + bool fileExists(const std::string& path); } // namespace io diff --git a/include/nxst/infra/net/transfer_receiver.hpp b/include/nxst/infra/net/transfer_receiver.hpp deleted file mode 100644 index 6f70f09..0000000 --- a/include/nxst/infra/net/transfer_receiver.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/include/nxst/infra/net/transfer_sender.hpp b/include/nxst/infra/net/transfer_sender.hpp deleted file mode 100644 index 6f70f09..0000000 --- a/include/nxst/infra/net/transfer_sender.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/include/nxst/infra/sys/logger.hpp b/include/nxst/infra/sys/logger.hpp index f8f6879..e357103 100644 --- a/include/nxst/infra/sys/logger.hpp +++ b/include/nxst/infra/sys/logger.hpp @@ -1,59 +1,15 @@ #pragma once -#include <cstring> -#include <string> // New API — use these going forward. namespace nxst::log { -enum class Level { Debug, Info, Warn, Error }; + enum class Level { Debug, Info, Warn, Error }; -void write(Level level, const char* fmt, ...) __attribute__((format(printf, 2, 3))); -void debug(const char* fmt, ...) __attribute__((format(printf, 1, 2))); -void info(const char* fmt, ...) __attribute__((format(printf, 1, 2))); -void warn(const char* fmt, ...) __attribute__((format(printf, 1, 2))); -void error(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + void write(Level level, const char* fmt, ...) __attribute__((format(printf, 2, 3))); + void debug(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + void info(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + void warn(const char* fmt, ...) __attribute__((format(printf, 1, 2))); + void error(const char* fmt, ...) __attribute__((format(printf, 1, 2))); -// No-op: writes are immediate. Kept for source compatibility during migration. -inline void flush() {} - -} // namespace nxst::log - -// Backward-compat shim — existing Logger::getInstance().log(...) call sites compile -// unchanged. Format args are dropped (same behavior as broken original). Migrate -// call sites to nxst::log::* in Phase 3. -struct Logger { - static Logger& getInstance() { - static Logger instance; - return instance; - } - - // clang-tidy naming suppressed: these must match existing call sites during migration. - static constexpr const char* INFO = "[INFO]"; // NOLINT(readability-identifier-naming) - static constexpr const char* DEBUG = "[DEBUG]"; // NOLINT(readability-identifier-naming) - static constexpr const char* ERROR = "[ERROR]"; // NOLINT(readability-identifier-naming) - static constexpr const char* WARN = "[WARN]"; // NOLINT(readability-identifier-naming) - - static void flush() { - nxst::log::flush(); - } - - // Args intentionally dropped — format string still logged for visibility. - template <typename... Args> - void log(const std::string& level, const std::string& fmt, Args&&... /*args*/) { - if (level == ERROR) - nxst::log::error("%s", fmt.c_str()); - else if (level == WARN) - nxst::log::warn("%s", fmt.c_str()); - else if (level == DEBUG) - nxst::log::debug("%s", fmt.c_str()); - else - nxst::log::info("%s", fmt.c_str()); - } - - Logger() = default; - ~Logger() = default; - - Logger(const Logger&) = delete; // NOLINT(modernize-use-equals-delete) - Logger& operator=(const Logger&) = delete; // NOLINT(modernize-use-equals-delete) -}; +} // namespace nxst::log \ No newline at end of file diff --git a/include/nxst/service/transfer_service.hpp b/include/nxst/service/transfer_service.hpp index 8093374..886adce 100644 --- a/include/nxst/service/transfer_service.hpp +++ b/include/nxst/service/transfer_service.hpp @@ -9,105 +9,105 @@ namespace nxst { -class TransferService { - public: - int startSend(size_t title_index, AccountUid uid); - void cancelSend(); + class TransferService { + public: + int startSend(size_t title_index, AccountUid uid); + void cancelSend(); - bool isSendDone() const { - return sender_state.done.load(); - } - bool isSendCancelled() const { - return sender_state.cancelled.load(); - } - bool isSendConnectionFailed() const { - return sender_state.connection_failed.load(); - } - bool isSendProgressKnown() const { - return sender_state.bytes_total.load() > 0; - } - bool isSendWorkersIdle() const { - return !sender_active.load(); - } - double sendProgress() const { - return sender_state.progress(); - } - std::string sendStatusText() const { - return sender_state.getStatus(); - } - std::string sendFailReason() const { - return sender_state.fail_reason; - } + bool isSendDone() const { + return sender_state.done.load(); + } + bool isSendCancelled() const { + return sender_state.cancelled.load(); + } + bool isSendConnectionFailed() const { + return sender_state.connection_failed.load(); + } + bool isSendProgressKnown() const { + return sender_state.bytes_total.load() > 0; + } + bool isSendWorkersIdle() const { + return !sender_active.load(); + } + double sendProgress() const { + return sender_state.progress(); + } + std::string sendStatusText() const { + return sender_state.getStatus(); + } + std::string sendFailReason() const { + return sender_state.fail_reason; + } - int startReceive(size_t title_index, AccountUid uid, std::string title_name); - void cancelReceive(); + int startReceive(size_t title_index, AccountUid uid, std::string title_name); + void cancelReceive(); - bool isReceiveDone() const { - return receiver_state.done.load(); - } - bool isReceiveCancelled() const { - return receiver_state.cancelled.load(); - } - bool isReceiveWorkersIdle() const { - return !receiver_accept_active.load() && !receiver_broadcast_active.load(); - } - double receiveProgress() const { - return receiver_state.progress(); - } - std::string receiveStatusText() const { - return receiver_state.getStatus(); - } - bool restoreSucceeded() const { - return restore_ok; - } - std::string restoreError() const { - return restore_error; - } + bool isReceiveDone() const { + return receiver_state.done.load(); + } + bool isReceiveCancelled() const { + return receiver_state.cancelled.load(); + } + bool isReceiveWorkersIdle() const { + return !receiver_accept_active.load() && !receiver_broadcast_active.load(); + } + double receiveProgress() const { + return receiver_state.progress(); + } + std::string receiveStatusText() const { + return receiver_state.getStatus(); + } + bool restoreSucceeded() const { + return restore_ok; + } + std::string restoreError() const { + return restore_error; + } - private: - // Sender - TransferState sender_state; - std::atomic<int> sender_udp_sock{-1}; - std::atomic<int> sender_tcp_sock{-1}; - std::atomic<bool> sender_active{false}; + private: + // Sender + TransferState sender_state; + std::atomic<int> sender_udp_sock{-1}; + std::atomic<int> sender_tcp_sock{-1}; + std::atomic<bool> sender_active{false}; - // Receiver - TransferState receiver_state; - std::atomic<int> receiver_client_sock{-1}; - std::atomic<int> receiver_listen_sock{-1}; - std::atomic<int> receiver_bcast_sock{-1}; - std::atomic<bool> receiver_accept_active{false}; - std::atomic<bool> receiver_broadcast_active{false}; - pthread_t receiver_bcast_thread{}; + // Receiver + TransferState receiver_state; + std::atomic<int> receiver_client_sock{-1}; + std::atomic<int> receiver_listen_sock{-1}; + std::atomic<int> receiver_bcast_sock{-1}; + std::atomic<bool> receiver_accept_active{false}; + std::atomic<bool> receiver_broadcast_active{false}; + pthread_t receiver_bcast_thread{}; - // Stored at startReceive, read after network transfer completes - size_t restore_title_index{0}; - AccountUid restore_uid{}; - std::string restore_title_name; - bool restore_ok{false}; - std::string restore_error; + // Stored at startReceive, read after network transfer completes + size_t restore_title_index{0}; + AccountUid restore_uid{}; + std::string restore_title_name; + bool restore_ok{false}; + std::string restore_error; - // Sender thread - struct SenderArgs { - TransferService* svc; - size_t title_index; - AccountUid uid; + // Sender thread + struct SenderArgs { + TransferService* svc; + size_t title_index; + AccountUid uid; + }; + static void* senderEntry(void* arg); + void runSender(size_t title_index, AccountUid uid); + void failSend(const std::string& reason); + int findServer(char* out_ip); + + // Receiver threads + struct AcceptArgs { + TransferService* svc; + int server_fd; + }; + static void* broadcastEntry(void* arg); + static void* acceptEntry(void* arg); + void runBroadcast(); + void runAccept(int server_fd); + std::string replaceUsername(const std::string& file_path) const; }; - static void* senderEntry(void* arg); - void runSender(size_t title_index, AccountUid uid); - void failSend(const std::string& reason); - int findServer(char* out_ip); - - // Receiver threads - struct AcceptArgs { - TransferService* svc; - int server_fd; - }; - static void* broadcastEntry(void* arg); - static void* acceptEntry(void* arg); - void runBroadcast(); - void runAccept(int server_fd); - std::string replaceUsername(const std::string& file_path) const; -}; } // namespace nxst diff --git a/include/nxst/ui/card.hpp b/include/nxst/ui/card.hpp deleted file mode 100644 index 6d62e86..0000000 --- a/include/nxst/ui/card.hpp +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once -#include <pu/Plutonium> - -#include <nxst/ui/theme.hpp> - -namespace ui { - -class Card { - public: - pu::ui::elm::Rectangle::Ref bg; - - Card(pu::ui::Layout* parent, int x, int y, int w, int h, pu::ui::Color color = theme::color::BgSurface, - int rad = theme::radius::lg) { - bg = pu::ui::elm::Rectangle::New(x, y, w, h, color, rad); - parent->Add(bg); - } -}; -} // namespace ui diff --git a/include/nxst/ui/const.h b/include/nxst/ui/const.h deleted file mode 100644 index 6d9908f..0000000 --- a/include/nxst/ui/const.h +++ /dev/null @@ -1,6 +0,0 @@ -#pragma once - -#include <nxst/ui/theme.hpp> - -#define COLOR(hex) pu::ui::Color::FromHex(hex) -#define BACKGROUND_COLOR theme::color::BgBase diff --git a/include/nxst/ui/header_bar.hpp b/include/nxst/ui/header_bar.hpp index 6a79a41..40ce919 100644 --- a/include/nxst/ui/header_bar.hpp +++ b/include/nxst/ui/header_bar.hpp @@ -3,81 +3,80 @@ #include <nxst/domain/account.hpp> #include <nxst/ui/theme.hpp> -#include <nxst/ui/ui_context.hpp> namespace ui { -class HeaderBar { - private: - pu::ui::elm::Rectangle::Ref bg; - pu::ui::elm::Rectangle::Ref divider; - pu::ui::elm::TextBlock::Ref appName; - pu::ui::elm::TextBlock::Ref subtitle; - pu::ui::elm::Rectangle::Ref chipBg; - pu::ui::elm::Image::Ref avatar; - pu::ui::elm::TextBlock::Ref userName; + class HeaderBar { + private: + pu::ui::elm::Rectangle::Ref bg; + pu::ui::elm::Rectangle::Ref divider; + pu::ui::elm::TextBlock::Ref appName; + pu::ui::elm::TextBlock::Ref subtitle; + pu::ui::elm::Rectangle::Ref chipBg; + pu::ui::elm::Image::Ref avatar; + pu::ui::elm::TextBlock::Ref userName; - public: - HeaderBar(pu::ui::Layout* parent, const std::string& sub = "Save Transfer") { - using namespace theme; + public: + HeaderBar(pu::ui::Layout* parent, const std::string& sub = "Save Transfer") { + using namespace theme; - bg = pu::ui::elm::Rectangle::New(0, 0, layout::ScreenW, layout::HeaderH, color::BgSurface); - divider = pu::ui::elm::Rectangle::New(0, layout::HeaderH - 1, layout::ScreenW, 1, color::Divider); + bg = pu::ui::elm::Rectangle::New(0, 0, layout::ScreenW, layout::HeaderH, color::BgSurface); + divider = pu::ui::elm::Rectangle::New(0, layout::HeaderH - 1, layout::ScreenW, 1, color::Divider); - appName = pu::ui::elm::TextBlock::New(space::lg, 8, "NXST"); - appName->SetFont(type::font(type::Title)); - appName->SetColor(color::TextPrimary); + appName = pu::ui::elm::TextBlock::New(space::lg, 8, "NXST"); + appName->SetFont(type::font(type::Title)); + appName->SetColor(color::TextPrimary); - subtitle = pu::ui::elm::TextBlock::New(space::lg, 46, sub); - subtitle->SetFont(type::font(type::Caption)); - subtitle->SetColor(color::TextMuted); + subtitle = pu::ui::elm::TextBlock::New(space::lg, 46, sub); + subtitle->SetFont(type::font(type::Caption)); + subtitle->SetColor(color::TextMuted); - const int chipW = 280; - const int chipX = layout::ScreenW - chipW - space::lg; - chipBg = pu::ui::elm::Rectangle::New(chipX, 16, chipW, 40, color::BgSurface2, radius::pill); - chipBg->SetVisible(false); + const int chipW = 280; + const int chipX = layout::ScreenW - chipW - space::lg; + chipBg = pu::ui::elm::Rectangle::New(chipX, 16, chipW, 40, color::BgSurface2, radius::pill); + chipBg->SetVisible(false); - avatar = pu::ui::elm::Image::New(chipX + 4, 20, ""); - avatar->SetWidth(32); - avatar->SetHeight(32); - avatar->SetVisible(false); + avatar = pu::ui::elm::Image::New(chipX + 4, 20, ""); + avatar->SetWidth(32); + avatar->SetHeight(32); + avatar->SetVisible(false); - userName = pu::ui::elm::TextBlock::New(chipX + 44, 24, ""); - userName->SetFont(type::font(type::Body)); - userName->SetColor(color::TextPrimary); - userName->SetVisible(false); + userName = pu::ui::elm::TextBlock::New(chipX + 44, 24, ""); + userName->SetFont(type::font(type::Body)); + userName->SetColor(color::TextPrimary); + userName->SetVisible(false); - parent->Add(bg); - parent->Add(divider); - parent->Add(appName); - parent->Add(subtitle); - parent->Add(chipBg); - parent->Add(avatar); - parent->Add(userName); - } + parent->Add(bg); + parent->Add(divider); + parent->Add(appName); + parent->Add(subtitle); + parent->Add(chipBg); + parent->Add(avatar); + parent->Add(userName); + } - void SetUser(const std::optional<AccountUid>& uid, const std::string& name) { - const bool show = uid.has_value(); - chipBg->SetVisible(show); - userName->SetVisible(show); - if (show) { - userName->SetText(name); - std::string path = Account::iconPath(*uid); - if (!path.empty()) { - avatar->SetImage(path); - avatar->SetWidth(32); - avatar->SetHeight(32); - avatar->SetVisible(avatar->IsImageValid()); + void SetUser(const std::optional<AccountUid>& uid, const std::string& name) { + const bool show = uid.has_value(); + chipBg->SetVisible(show); + userName->SetVisible(show); + if (show) { + userName->SetText(name); + std::string path = account::iconPath(*uid); + if (!path.empty()) { + avatar->SetImage(path); + avatar->SetWidth(32); + avatar->SetHeight(32); + avatar->SetVisible(avatar->IsImageValid()); + } else { + avatar->SetVisible(false); + } } else { avatar->SetVisible(false); } - } else { - avatar->SetVisible(false); } - } - void SetSubtitle(const std::string& text) { - subtitle->SetText(text); - } -}; + void SetSubtitle(const std::string& text) { + subtitle->SetText(text); + } + }; } // namespace ui diff --git a/include/nxst/ui/hint_bar.hpp b/include/nxst/ui/hint_bar.hpp index 89a90d3..322ecd3 100644 --- a/include/nxst/ui/hint_bar.hpp +++ b/include/nxst/ui/hint_bar.hpp @@ -8,49 +8,49 @@ namespace ui { -struct Hint { - std::string glyph; - std::string label; -}; + struct Hint { + std::string glyph; + std::string label; + }; -class HintBar { - private: - pu::ui::Layout* parent; - pu::ui::elm::Rectangle::Ref bg; - pu::ui::elm::Rectangle::Ref divider; - std::vector<pu::ui::elm::TextBlock::Ref> labels; + class HintBar { + private: + pu::ui::Layout* parent; + pu::ui::elm::Rectangle::Ref bg; + pu::ui::elm::Rectangle::Ref divider; + std::vector<pu::ui::elm::TextBlock::Ref> labels; - public: - HintBar(pu::ui::Layout* p) : parent(p) { - using namespace theme; - bg = pu::ui::elm::Rectangle::New(0, layout::ScreenH - layout::HintH, layout::ScreenW, layout::HintH, - color::BgSurface); - divider = pu::ui::elm::Rectangle::New(0, layout::ScreenH - layout::HintH, layout::ScreenW, 1, - color::Divider); - parent->Add(bg); - parent->Add(divider); - } - - void SetHints(const std::vector<Hint>& hints) { - using namespace theme; - for (auto& l : labels) - l->SetVisible(false); - labels.clear(); - - int x = layout::ScreenW - space::lg; - int y = layout::ScreenH - layout::HintH + 18; - for (auto it = hints.rbegin(); it != hints.rend(); ++it) { - std::string text = it->glyph + " " + it->label; - auto tb = pu::ui::elm::TextBlock::New(0, y, text); - tb->SetFont(type::font(type::Label)); - tb->SetColor(color::TextSecondary); - int w = tb->GetWidth(); - x -= w; - tb->SetX(x); - x -= space::xl; - parent->Add(tb); - labels.push_back(tb); + public: + HintBar(pu::ui::Layout* p) : parent(p) { + using namespace theme; + bg = pu::ui::elm::Rectangle::New(0, layout::ScreenH - layout::HintH, layout::ScreenW, + layout::HintH, color::BgSurface); + divider = pu::ui::elm::Rectangle::New(0, layout::ScreenH - layout::HintH, layout::ScreenW, 1, + color::Divider); + parent->Add(bg); + parent->Add(divider); } - } -}; + + void SetHints(const std::vector<Hint>& hints) { + using namespace theme; + for (auto& l : labels) + l->SetVisible(false); + labels.clear(); + + int x = layout::ScreenW - space::lg; + int y = layout::ScreenH - layout::HintH + 18; + for (auto it = hints.rbegin(); it != hints.rend(); ++it) { + std::string text = it->glyph + " " + it->label; + auto tb = pu::ui::elm::TextBlock::New(0, y, text); + tb->SetFont(type::font(type::Label)); + tb->SetColor(color::TextSecondary); + int w = tb->GetWidth(); + x -= w; + tb->SetX(x); + x -= space::xl; + parent->Add(tb); + labels.push_back(tb); + } + } + }; } // namespace ui diff --git a/include/nxst/ui/theme.hpp b/include/nxst/ui/theme.hpp index 7a3b677..a974c8a 100644 --- a/include/nxst/ui/theme.hpp +++ b/include/nxst/ui/theme.hpp @@ -5,75 +5,75 @@ #include <pu/Plutonium> namespace theme { -using pu::ui::Color; + using pu::ui::Color; -namespace color { -constexpr Color BgBase{0x10, 0x14, 0x1C, 0xFF}; -constexpr Color BgSurface{0x18, 0x1F, 0x2A, 0xFF}; -constexpr Color BgSurface2{0x22, 0x2B, 0x39, 0xFF}; -constexpr Color Scrim{0x00, 0x00, 0x00, 0xB8}; + namespace color { + constexpr Color BgBase{0x10, 0x14, 0x1C, 0xFF}; + constexpr Color BgSurface{0x18, 0x1F, 0x2A, 0xFF}; + constexpr Color BgSurface2{0x22, 0x2B, 0x39, 0xFF}; + constexpr Color Scrim{0x00, 0x00, 0x00, 0xB8}; -constexpr Color Primary{0xE2, 0x4B, 0x55, 0xFF}; -constexpr Color PrimaryDim{0x9C, 0x33, 0x3A, 0xFF}; -constexpr Color Accent{0x4A, 0xC2, 0xE0, 0xFF}; + constexpr Color Primary{0xE2, 0x4B, 0x55, 0xFF}; + constexpr Color PrimaryDim{0x9C, 0x33, 0x3A, 0xFF}; + constexpr Color Accent{0x4A, 0xC2, 0xE0, 0xFF}; -constexpr Color TextPrimary{0xF2, 0xF4, 0xF8, 0xFF}; -constexpr Color TextSecondary{0xB6, 0xBE, 0xCB, 0xFF}; -constexpr Color TextMuted{0x70, 0x7A, 0x8C, 0xFF}; + constexpr Color TextPrimary{0xF2, 0xF4, 0xF8, 0xFF}; + constexpr Color TextSecondary{0xB6, 0xBE, 0xCB, 0xFF}; + constexpr Color TextMuted{0x70, 0x7A, 0x8C, 0xFF}; -constexpr Color Success{0x55, 0xC8, 0x8A, 0xFF}; -constexpr Color Error{0xE0, 0x6C, 0x6C, 0xFF}; -constexpr Color Warning{0xE6, 0xB4, 0x55, 0xFF}; + constexpr Color Success{0x55, 0xC8, 0x8A, 0xFF}; + constexpr Color Error{0xE0, 0x6C, 0x6C, 0xFF}; + constexpr Color Warning{0xE6, 0xB4, 0x55, 0xFF}; -constexpr Color Divider{0x2A, 0x33, 0x42, 0xFF}; -constexpr Color FocusRing{0xE2, 0x4B, 0x55, 0xFF}; -} // namespace color + constexpr Color Divider{0x2A, 0x33, 0x42, 0xFF}; + constexpr Color FocusRing{0xE2, 0x4B, 0x55, 0xFF}; + } // namespace color -namespace space { -constexpr int xs = 4; -constexpr int sm = 8; -constexpr int md = 16; -constexpr int lg = 24; -constexpr int xl = 32; -constexpr int xxl = 48; -} // namespace space + namespace space { + constexpr int xs = 4; + constexpr int sm = 8; + constexpr int md = 16; + constexpr int lg = 24; + constexpr int xl = 32; + constexpr int xxl = 48; + } // namespace space -namespace radius { -constexpr int sm = 6; -constexpr int md = 12; -constexpr int lg = 20; -constexpr int pill = 9999; -} // namespace radius + namespace radius { + constexpr int sm = 6; + constexpr int md = 12; + constexpr int lg = 20; + constexpr int pill = 9999; + } // namespace radius -namespace type { -constexpr int Display = 38; -constexpr int Title = 30; -constexpr int Body = 25; -constexpr int Label = 20; -constexpr int Caption = 18; + namespace type { + constexpr int Display = 38; + constexpr int Title = 30; + constexpr int Body = 25; + constexpr int Label = 20; + constexpr int Caption = 18; -inline std::string font(int size) { - return "DefaultFont@" + std::to_string(size); -} -} // namespace type + inline std::string font(int size) { + return "DefaultFont@" + std::to_string(size); + } + } // namespace type -namespace layout { -constexpr int ScreenW = 1280; -constexpr int ScreenH = 720; -constexpr int HeaderH = 72; -constexpr int HintH = 56; -constexpr int ContentTop = HeaderH; -constexpr int ContentH = ScreenH - HeaderH - HintH; -} // namespace layout + namespace layout { + constexpr int ScreenW = 1280; + constexpr int ScreenH = 720; + constexpr int HeaderH = 72; + constexpr int HintH = 56; + constexpr int ContentTop = HeaderH; + constexpr int ContentH = ScreenH - HeaderH - HintH; + } // namespace layout -namespace motion { -constexpr int FadeFrames = 20; -constexpr int SlideFrames = 14; -constexpr int SpinnerFrames = 72; -} // namespace motion + namespace motion { + constexpr int FadeFrames = 20; + constexpr int SlideFrames = 14; + constexpr int SpinnerFrames = 72; + } // namespace motion -namespace font { -constexpr const char* Default = "Inter"; -constexpr const char* Medium = "InterMedium"; -} // namespace font + namespace font { + constexpr const char* Default = "Inter"; + constexpr const char* Medium = "InterMedium"; + } // namespace font } // namespace theme diff --git a/include/nxst/ui/titles_layout.hpp b/include/nxst/ui/titles_layout.hpp index f20dbae..b7b507c 100644 --- a/include/nxst/ui/titles_layout.hpp +++ b/include/nxst/ui/titles_layout.hpp @@ -7,57 +7,56 @@ #include <nxst/domain/account.hpp> #include <nxst/domain/title.hpp> -#include <nxst/ui/const.h> #include <nxst/ui/header_bar.hpp> #include <nxst/ui/hint_bar.hpp> namespace ui { -enum class TitlesFocus { List, Actions }; -enum class TitlesAction { Transfer, Receive }; + enum class TitlesFocus { List, Actions }; + enum class TitlesAction { Transfer, Receive }; -class TitlesLayout : public pu::ui::Layout { - private: - pu::ui::elm::Menu::Ref titlesMenu; - std::unordered_map<AccountUid, std::vector<pu::ui::elm::MenuItem::Ref>> menuCache; - bool m_inputLocked = false; - std::unique_ptr<HeaderBar> header; - std::unique_ptr<HintBar> hints; + class TitlesLayout : public pu::ui::Layout { + private: + pu::ui::elm::Menu::Ref titlesMenu; + std::unordered_map<AccountUid, std::vector<pu::ui::elm::MenuItem::Ref>> menuCache; + bool m_inputLocked = false; + std::unique_ptr<HeaderBar> header; + std::unique_ptr<HintBar> hints; - pu::ui::elm::Rectangle::Ref panelBg; - pu::ui::elm::TextBlock::Ref panelTitle; - pu::ui::elm::TextBlock::Ref panelHint; - pu::ui::elm::Rectangle::Ref btnTransferBg; - pu::ui::elm::TextBlock::Ref btnTransferText; - pu::ui::elm::Rectangle::Ref btnReceiveBg; - pu::ui::elm::TextBlock::Ref btnReceiveText; - pu::ui::elm::TextBlock::Ref panelFooter; - pu::ui::elm::TextBlock::Ref emptyText; - pu::ui::elm::TextBlock::Ref emptySub; + pu::ui::elm::Rectangle::Ref panelBg; + pu::ui::elm::TextBlock::Ref panelTitle; + pu::ui::elm::TextBlock::Ref panelHint; + pu::ui::elm::Rectangle::Ref btnTransferBg; + pu::ui::elm::TextBlock::Ref btnTransferText; + pu::ui::elm::Rectangle::Ref btnReceiveBg; + pu::ui::elm::TextBlock::Ref btnReceiveText; + pu::ui::elm::TextBlock::Ref panelFooter; + pu::ui::elm::TextBlock::Ref emptyText; + pu::ui::elm::TextBlock::Ref emptySub; - AccountUid current_uid{}; - TitlesFocus focus = TitlesFocus::List; - TitlesAction action = TitlesAction::Transfer; - int lockedListIndex = 0; + AccountUid current_uid{}; + TitlesFocus focus = TitlesFocus::List; + TitlesAction action = TitlesAction::Transfer; + int lockedListIndex = 0; - void refreshPanel(); - void refreshButtons(); - void updateHints(); - void runTransfer(int index, Title& title); - void runReceive(int index, Title& title); + void refreshPanel(); + void refreshButtons(); + void updateHints(); + void runTransfer(int index, Title& title); + void runReceive(int index, Title& title); - public: - TitlesLayout(); - void InitTitles(AccountUid uid); - void LockInput() { - m_inputLocked = true; - } - void UnlockInput() { - m_inputLocked = false; - } + public: + TitlesLayout(); + void InitTitles(AccountUid uid); + void LockInput() { + m_inputLocked = true; + } + void UnlockInput() { + m_inputLocked = false; + } - void onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos); + void onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos); - PU_SMART_CTOR(TitlesLayout) -}; + PU_SMART_CTOR(TitlesLayout) + }; } // namespace ui diff --git a/include/nxst/ui/transfer_overlay.hpp b/include/nxst/ui/transfer_overlay.hpp index 16db4e0..1d17b33 100644 --- a/include/nxst/ui/transfer_overlay.hpp +++ b/include/nxst/ui/transfer_overlay.hpp @@ -6,79 +6,79 @@ namespace ui { -class TransferOverlay : public pu::ui::Overlay { - private: - pu::ui::elm::Rectangle::Ref card; - pu::ui::elm::TextBlock::Ref titleText; - pu::ui::elm::TextBlock::Ref statusText; - pu::ui::elm::Rectangle::Ref progressTrack; - pu::ui::elm::ProgressBar::Ref progressBar; - pu::ui::elm::TextBlock::Ref indeterminateText; - pu::ui::elm::TextBlock::Ref hintText; + class TransferOverlay : public pu::ui::Overlay { + private: + pu::ui::elm::Rectangle::Ref card; + pu::ui::elm::TextBlock::Ref titleText; + pu::ui::elm::TextBlock::Ref statusText; + pu::ui::elm::Rectangle::Ref progressTrack; + pu::ui::elm::ProgressBar::Ref progressBar; + pu::ui::elm::TextBlock::Ref indeterminateText; + pu::ui::elm::TextBlock::Ref hintText; - static constexpr int CardW = 720; - static constexpr int CardH = 360; - static constexpr int CardX = (theme::layout::ScreenW - CardW) / 2; - static constexpr int CardY = (theme::layout::ScreenH - CardH) / 2; + static constexpr int CardW = 720; + static constexpr int CardH = 360; + static constexpr int CardX = (theme::layout::ScreenW - CardW) / 2; + static constexpr int CardY = (theme::layout::ScreenH - CardH) / 2; - public: - TransferOverlay(const std::string& title) - : Overlay(0, 0, theme::layout::ScreenW, theme::layout::ScreenH, theme::color::Scrim) { - using namespace theme; + public: + TransferOverlay(const std::string& title) + : Overlay(0, 0, theme::layout::ScreenW, theme::layout::ScreenH, theme::color::Scrim) { + using namespace theme; - card = pu::ui::elm::Rectangle::New(CardX, CardY, CardW, CardH, color::BgSurface, radius::lg); + card = pu::ui::elm::Rectangle::New(CardX, CardY, CardW, CardH, color::BgSurface, radius::lg); - titleText = pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + space::lg, title); - titleText->SetFont(type::font(type::Title)); - titleText->SetColor(color::TextPrimary); + titleText = pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + space::lg, title); + titleText->SetFont(type::font(type::Title)); + titleText->SetColor(color::TextPrimary); - statusText = pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + space::lg + 56, ""); - statusText->SetFont(type::font(type::Body)); - statusText->SetColor(color::TextSecondary); + statusText = pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + space::lg + 56, ""); + statusText->SetFont(type::font(type::Body)); + statusText->SetColor(color::TextSecondary); - int barX = CardX + space::lg; - int barY = CardY + space::lg + 56 + 56; - int barW = CardW - 2 * space::lg; + int barX = CardX + space::lg; + int barY = CardY + space::lg + 56 + 56; + int barW = CardW - 2 * space::lg; - progressTrack = pu::ui::elm::Rectangle::New(barX, barY, barW, 8, color::Divider, radius::sm); + progressTrack = pu::ui::elm::Rectangle::New(barX, barY, barW, 8, color::Divider, radius::sm); - progressBar = pu::ui::elm::ProgressBar::New(barX, barY, barW, 8, 100.0); - progressBar->SetProgressColor(color::Primary); - progressBar->SetBackgroundColor(color::Divider); + progressBar = pu::ui::elm::ProgressBar::New(barX, barY, barW, 8, 100.0); + progressBar->SetProgressColor(color::Primary); + progressBar->SetBackgroundColor(color::Divider); - indeterminateText = pu::ui::elm::TextBlock::New(barX, barY - 4, "Preparing transfer..."); - indeterminateText->SetFont(type::font(type::Body)); - indeterminateText->SetColor(color::TextMuted); - indeterminateText->SetVisible(false); + indeterminateText = pu::ui::elm::TextBlock::New(barX, barY - 4, "Preparing transfer..."); + indeterminateText->SetFont(type::font(type::Body)); + indeterminateText->SetColor(color::TextMuted); + indeterminateText->SetVisible(false); - hintText = - pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + CardH - space::lg - 18, "B to cancel"); - hintText->SetFont(type::font(type::Caption)); - hintText->SetColor(color::TextMuted); + hintText = + pu::ui::elm::TextBlock::New(CardX + space::lg, CardY + CardH - space::lg - 18, "B to cancel"); + hintText->SetFont(type::font(type::Caption)); + hintText->SetColor(color::TextMuted); - this->Add(card); - this->Add(titleText); - this->Add(statusText); - this->Add(progressTrack); - this->Add(progressBar); - this->Add(indeterminateText); - this->Add(hintText); - } - PU_SMART_CTOR(TransferOverlay) + this->Add(card); + this->Add(titleText); + this->Add(statusText); + this->Add(progressTrack); + this->Add(progressBar); + this->Add(indeterminateText); + this->Add(hintText); + } + PU_SMART_CTOR(TransferOverlay) - void SetStatus(const std::string& status) { - statusText->SetText(StringUtils::elide(status, 56)); - } + void SetStatus(const std::string& status) { + statusText->SetText(string_utils::elide(status, 56)); + } - void SetProgress(double val) { - progressBar->SetProgress(val); - } + void SetProgress(double val) { + progressBar->SetProgress(val); + } - void SetProgressVisible(bool visible) { - progressTrack->SetVisible(visible); - progressBar->SetVisible(visible); - indeterminateText->SetVisible(!visible); - } -}; + void SetProgressVisible(bool visible) { + progressTrack->SetVisible(visible); + progressBar->SetVisible(visible); + indeterminateText->SetVisible(!visible); + } + }; } // namespace ui diff --git a/include/nxst/ui/ui_context.hpp b/include/nxst/ui/ui_context.hpp deleted file mode 100644 index 18e2f99..0000000 --- a/include/nxst/ui/ui_context.hpp +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once -#include <optional> -#include <string> - -#include <switch.h> - -#include <nxst/domain/account.hpp> - -namespace ui { -struct UiContext { - std::optional<AccountUid> selectedUser; - std::string selectedUserName; -}; -} // namespace ui diff --git a/include/nxst/ui/users_layout.hpp b/include/nxst/ui/users_layout.hpp index e01072d..c037621 100644 --- a/include/nxst/ui/users_layout.hpp +++ b/include/nxst/ui/users_layout.hpp @@ -2,27 +2,26 @@ #include <pu/Plutonium> -#include <nxst/ui/const.h> #include <nxst/ui/header_bar.hpp> #include <nxst/ui/hint_bar.hpp> namespace ui { -class UsersLayout : public pu::ui::Layout { - private: - pu::ui::elm::Menu::Ref usersMenu; - pu::ui::elm::Rectangle::Ref loadingBg; - pu::ui::elm::TextBlock::Ref loadingText; - std::unique_ptr<HeaderBar> header; - std::unique_ptr<HintBar> hints; + class UsersLayout : public pu::ui::Layout { + private: + pu::ui::elm::Menu::Ref usersMenu; + pu::ui::elm::Rectangle::Ref loadingBg; + pu::ui::elm::TextBlock::Ref loadingText; + std::unique_ptr<HeaderBar> header; + std::unique_ptr<HintBar> hints; - public: - UsersLayout(); + public: + UsersLayout(); - void onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos); + void onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos); - int32_t GetCurrentIndex(); + int32_t GetCurrentIndex(); - PU_SMART_CTOR(UsersLayout) -}; + PU_SMART_CTOR(UsersLayout) + }; } // namespace ui diff --git a/src/app/main.cpp b/src/app/main.cpp index 12654c2..d95d70b 100644 --- a/src/app/main.cpp +++ b/src/app/main.cpp @@ -1,11 +1,10 @@ #include <unistd.h> -#include <nxst/app/main.hpp> #include <nxst/app/main_application.hpp> #include <nxst/domain/util.hpp> namespace ui { -extern MainApplication* mainApp; + extern MainApplication* mainApp; } static int nxlink_sock = -1; diff --git a/src/app/main_application.cpp b/src/app/main_application.cpp index dcf627a..593a214 100644 --- a/src/app/main_application.cpp +++ b/src/app/main_application.cpp @@ -1,24 +1,20 @@ -#include <string> -#include <switch/services/hid.h> -#include <vector> - #include <switch.h> #include <nxst/app/main_application.hpp> namespace ui { -MainApplication* mainApp; + MainApplication* mainApp; -void MainApplication::OnLoad() { - mainApp = this; - this->users_layout = UsersLayout::New(); - this->titles_layout = TitlesLayout::New(); - this->users_layout->SetOnInput(std::bind(&UsersLayout::onInput, this->users_layout, std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3, - std::placeholders::_4)); - this->titles_layout->SetOnInput(std::bind(&TitlesLayout::onInput, this->titles_layout, - std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, std::placeholders::_4)); - this->LoadLayout(this->users_layout); -} + void MainApplication::OnLoad() { + mainApp = this; + this->users_layout = UsersLayout::New(); + this->titles_layout = TitlesLayout::New(); + this->users_layout->SetOnInput(std::bind(&UsersLayout::onInput, this->users_layout, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4)); + this->titles_layout->SetOnInput(std::bind(&TitlesLayout::onInput, this->titles_layout, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4)); + this->LoadLayout(this->users_layout); + } } // namespace ui \ No newline at end of file diff --git a/src/domain/account.cpp b/src/domain/account.cpp index 40627f1..adcb23b 100644 --- a/src/domain/account.cpp +++ b/src/domain/account.cpp @@ -1,38 +1,16 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #include <cstdio> +#include <cstring> +#include <map> #include <sys/stat.h> +#include <vector> #include <nxst/domain/account.hpp> #include <nxst/infra/fs/handles.hpp> -static std::map<AccountUid, User> mUsers; +static std::map<AccountUid, User> s_users; -Result Account::init(void) { +Result account::init() { Result res = accountInitialize(AccountServiceType_Application); if (R_FAILED(res)) return res; @@ -40,51 +18,50 @@ Result Account::init(void) { AccountUid uids[8]; s32 count = 0; accountListAllUsers(uids, 8, &count); - for (s32 i = 0; i < count; i++) { - Account::username(uids[i]); // populates mUsers as side effect + for (s32 i = 0; i < count; ++i) { + username(uids[i]); // populate cache } return 0; } -void Account::exit(void) { +void account::exit() { accountExit(); } -std::vector<AccountUid> Account::ids(void) { - std::vector<AccountUid> v; - for (auto& value : mUsers) { - v.push_back(value.second.id); +std::vector<AccountUid> account::ids() { + std::vector<AccountUid> result; + result.reserve(s_users.size()); + for (const auto& pair : s_users) { + result.push_back(pair.second.id); } - return v; + return result; } -static User getUser(AccountUid id) { +static User fetchUser(AccountUid id) { User user{id, ""}; nxst::AccountProfileHandle profile; - AccountProfileBase profilebase; - memset(&profilebase, 0, sizeof(profilebase)); + AccountProfileBase base{}; if (R_SUCCEEDED(accountGetProfile(profile.get(), id))) { profile.valid = true; - if (R_SUCCEEDED(accountProfileGet(profile.get(), NULL, &profilebase))) { - user.name = std::string(profilebase.nickname); + if (R_SUCCEEDED(accountProfileGet(profile.get(), nullptr, &base))) { + user.name = std::string(base.nickname); } } return user; } -std::string Account::username(AccountUid id) { - std::map<AccountUid, User>::const_iterator got = mUsers.find(id); - if (got == mUsers.end()) { - User user = getUser(id); - mUsers.insert({id, user}); +std::string account::username(AccountUid id) { + auto it = s_users.find(id); + if (it == s_users.end()) { + User user = fetchUser(id); + s_users.emplace(id, user); return user.name; } - - return got->second.name; + return it->second.name; } -std::string Account::iconPath(AccountUid id) { +std::string account::iconPath(AccountUid id) { char path[128]; snprintf(path, sizeof(path), "sdmc:/switch/NXST/cache/%016lX%016lX.jpg", id.uid[0], id.uid[1]); @@ -101,37 +78,18 @@ std::string Account::iconPath(AccountUid id) { return ""; profile.valid = true; - u32 imgSize = 0; - if (R_FAILED(accountProfileGetImageSize(profile.get(), &imgSize)) || imgSize == 0) + u32 img_size = 0; + if (R_FAILED(accountProfileGetImageSize(profile.get(), &img_size)) || img_size == 0) return ""; - std::vector<u8> buf(imgSize); - u32 outSize = 0; - if (R_FAILED(accountProfileLoadImage(profile.get(), buf.data(), imgSize, &outSize)) || outSize == 0) + std::vector<u8> buf(img_size); + u32 out_size = 0; + if (R_FAILED(accountProfileLoadImage(profile.get(), buf.data(), img_size, &out_size)) || out_size == 0) return ""; nxst::FileHandle f(fopen(path, "wb")); if (!f) return ""; - fwrite(buf.data(), 1, outSize, f.get()); + fwrite(buf.data(), 1, out_size, f.get()); return std::string(path); } - -AccountUid Account::selectAccount(void) { - LibAppletArgs args; - libappletArgsCreate(&args, 0x10000); - u8 st_in[0xA0] = {0}; - u8 st_out[0x18] = {0}; - size_t repsz; - - Result res = - libappletLaunch(AppletId_LibraryAppletPlayerSelect, &args, st_in, 0xA0, st_out, 0x18, &repsz); - if (R_SUCCEEDED(res)) { - u64 lres = *(u64*)st_out; - AccountUid uid = *(AccountUid*)&st_out[8]; - if (lres == 0) - return uid; - } - - return AccountUid{}; -} \ No newline at end of file diff --git a/src/domain/common.cpp b/src/domain/common.cpp deleted file mode 100644 index b59ca95..0000000 --- a/src/domain/common.cpp +++ /dev/null @@ -1,121 +0,0 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - -#include <nxst/domain/common.hpp> - -std::string DateTime::timeStr(void) { - time_t unixTime; - struct tm timeStruct; - time(&unixTime); - localtime_r(&unixTime, &timeStruct); - return StringUtils::format("%02i:%02i:%02i", timeStruct.tm_hour, timeStruct.tm_min, timeStruct.tm_sec); -} - -std::string DateTime::dateTimeStr(void) { - time_t unixTime; - struct tm timeStruct; - time(&unixTime); - localtime_r(&unixTime, &timeStruct); - return StringUtils::format("%04i%02i%02i-%02i%02i%02i", timeStruct.tm_year + 1900, timeStruct.tm_mon + 1, - timeStruct.tm_mday, timeStruct.tm_hour, timeStruct.tm_min, timeStruct.tm_sec); -} - -std::string DateTime::logDateTime(void) { - time_t unixTime; - struct tm timeStruct; - time(&unixTime); - localtime_r(&unixTime, &timeStruct); - return StringUtils::format("%04i-%02i-%02i %02i:%02i:%02i", timeStruct.tm_year + 1900, - timeStruct.tm_mon + 1, timeStruct.tm_mday, timeStruct.tm_hour, - timeStruct.tm_min, timeStruct.tm_sec); -} - -std::string StringUtils::UTF16toUTF8(const std::u16string& src) { - static std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert; - std::string dst = convert.to_bytes(src); - return dst; -} - -std::string StringUtils::removeForbiddenCharacters(std::string src) { - static const std::string illegalChars = ".,!\\/:?*\"<>|"; - for (size_t i = 0, sz = src.length(); i < sz; i++) { - if (illegalChars.find(src[i]) != std::string::npos) { - src[i] = ' '; - } - } - - size_t i; - for (i = src.length() - 1; i > 0 && src[i] == ' '; i--) - ; - src.erase(i + 1, src.length() - i); - - return src; -} - -std::string StringUtils::format(const std::string fmt_str, ...) { - va_list ap; - char* fp = NULL; - va_start(ap, fmt_str); - vasprintf(&fp, fmt_str.c_str(), ap); - va_end(ap); - std::unique_ptr<char[]> formatted(fp); - return std::string(formatted.get()); -} - -bool StringUtils::containsInvalidChar(const std::string& str) { - for (size_t i = 0, sz = str.length(); i < sz; i++) { - if (!isascii(str[i])) { - return true; - } - } - return false; -} - -void StringUtils::ltrim(std::string& s) { - s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) { - return !std::isspace(ch); - })); -} - -void StringUtils::rtrim(std::string& s) { - s.erase(std::find_if(s.rbegin(), s.rend(), - [](int ch) { - return !std::isspace(ch); - }) - .base(), - s.end()); -} - -void StringUtils::trim(std::string& s) { - ltrim(s); - rtrim(s); -} - -char* getConsoleIP(void) { - struct in_addr in; - in.s_addr = gethostid(); - return inet_ntoa(in); -} \ No newline at end of file diff --git a/src/domain/title.cpp b/src/domain/title.cpp index 38aacc4..21feb82 100644 --- a/src/domain/title.cpp +++ b/src/domain/title.cpp @@ -1,260 +1,206 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ +// Copyright (C) 2024-2026 NXST contributors +#include <algorithm> +#include <cstring> +#include <vector> -#include <nxst/app/main.hpp> +#include "nxst/domain/account.hpp" +#include <nxst/domain/util.hpp> #include <nxst/domain/title.hpp> +#include <nxst/domain/util.hpp> +#include <nxst/infra/fs/directory.hpp> +#include <nxst/infra/sys/logger.hpp> + +using sort_t = enum { SortAlpha, SortLastPlayed, SortPlayTime, SortModesCount }; +static constexpr const char* kEmptySave = "New..."; +static sort_t s_sort_mode = SortAlpha; static std::unordered_map<AccountUid, std::vector<Title>> titles; -static bool s_titlesLoaded = false; +static bool s_titles_loaded = false; -bool areTitlesLoaded(void) { - return s_titlesLoaded; -} - -void Title::init(u8 saveDataType, u64 id, AccountUid userID, const std::string& name, +void Title::init(u8 save_data_type, u64 title_id, AccountUid uid, const std::string& name, const std::string& author) { - mId = id; - mUserId = userID; - mSaveDataType = saveDataType; - mUserName = Account::username(userID); - mAuthor = author; - mName = name; - mSafeName = StringUtils::containsInvalidChar(name) ? StringUtils::format("0x%016llX", mId) - : StringUtils::removeForbiddenCharacters(name); - mPath = "sdmc:/switch/NXST/saves/" + StringUtils::format("0x%016llX", mId) + " " + mSafeName; + m_id = title_id; + m_uid = uid; + m_save_data_type = save_data_type; + m_user_name = account::username(uid); + m_author = author; + m_name = name; + m_safe_name = string_utils::containsInvalidChar(name) ? string_utils::format("0x%016llX", m_id) + : string_utils::removeForbiddenCharacters(name); + m_path = "sdmc:/switch/NXST/saves/" + string_utils::format("0x%016llX", m_id) + " " + m_safe_name; - std::string aname = StringUtils::removeAccents(mName); - size_t pos = aname.rfind(":"); - mDisplayName = std::make_pair(aname, ""); - if (pos != std::string::npos) { - std::string name1 = aname.substr(0, pos); - std::string name2 = aname.substr(pos + 1); - StringUtils::trim(name1); - StringUtils::trim(name2); - mDisplayName.first = name1; - mDisplayName.second = name2; + std::string aname = string_utils::removeAccents(m_name); + m_display_name = {aname, ""}; + + size_t colon = aname.rfind(':'); + if (colon != std::string::npos) { + std::string head = aname.substr(0, colon); + std::string tail = aname.substr(colon + 1); + string_utils::trim(head); + string_utils::trim(tail); + m_display_name = {head, tail}; } else { - // check for parenthesis - size_t pos1 = aname.rfind("("); - size_t pos2 = aname.rfind(")"); - if (pos1 != std::string::npos && pos2 != std::string::npos) { - std::string name1 = aname.substr(0, pos1); - std::string name2 = aname.substr(pos1 + 1, pos2 - 1 - pos1); - StringUtils::trim(name1); - StringUtils::trim(name2); - mDisplayName.first = name1; - mDisplayName.second = name2; + size_t open = aname.rfind('('); + size_t close = aname.rfind(')'); + if (open != std::string::npos && close != std::string::npos && close > open) { + std::string head = aname.substr(0, open); + std::string paren = aname.substr(open + 1, close - open - 1); + string_utils::trim(head); + string_utils::trim(paren); + m_display_name = {head, paren}; } } refreshDirectories(); } -u8 Title::saveDataType(void) { - return mSaveDataType; +u8 Title::saveDataType() const { + return m_save_data_type; +} +u64 Title::id() const { + return m_id; +} +u64 Title::saveId() const { + return m_save_id; +} +void Title::saveId(u64 id) { + m_save_id = id; +} +AccountUid Title::userId() const { + return m_uid; +} +std::string Title::userName() const { + return m_user_name; +} +std::string Title::author() const { + return m_author; +} +std::string Title::name() const { + return m_name; +} +std::pair<std::string, std::string> Title::displayName() const { + return m_display_name; +} +std::string Title::path() const { + return m_path; +} +std::string Title::fullPath(size_t index) const { + return m_full_save_paths.at(index); +} +std::vector<std::string> Title::saves() const { + return m_saves; +} +u64 Title::playTimeNanoseconds() const { + return m_play_time_ns; +} +void Title::playTimeNanoseconds(u64 ns) { + m_play_time_ns = ns; +} +u32 Title::lastPlayedTimestamp() const { + return m_last_played_ts; +} +void Title::lastPlayedTimestamp(u32 ts) { + m_last_played_ts = ts; } -u64 Title::id(void) { - return mId; +std::string Title::playTime() const { + const u64 minutes = m_play_time_ns / 60000000000ULL; + return string_utils::format("%d", minutes / 60) + ":" + string_utils::format("%02d", minutes % 60) + + " hours"; } -u64 Title::saveId(void) { - return mSaveId; -} +void Title::refreshDirectories() { + m_saves.clear(); + m_full_save_paths.clear(); -void Title::saveId(u64 saveId) { - mSaveId = saveId; -} - -AccountUid Title::userId(void) { - return mUserId; -} - -std::string Title::userName(void) { - return mUserName; -} - -std::string Title::author(void) { - return mAuthor; -} - -std::string Title::name(void) { - return mName; -} - -std::pair<std::string, std::string> Title::displayName(void) { - return mDisplayName; -} - -std::string Title::path(void) { - return mPath; -} - -std::string Title::fullPath(size_t index) { - return mFullSavePaths.at(index); -} - -std::vector<std::string> Title::saves() { - return mSaves; -} - -u64 Title::playTimeNanoseconds(void) { - return mPlayTimeNanoseconds; -} - -std::string Title::playTime(void) { - const u64 playTimeMinutes = mPlayTimeNanoseconds / 60000000000; - return StringUtils::format("%d", playTimeMinutes / 60) + ":" + - StringUtils::format("%02d", playTimeMinutes % 60) + " hours"; -} - -void Title::playTimeNanoseconds(u64 playTimeNanoseconds) { - mPlayTimeNanoseconds = playTimeNanoseconds; -} - -u32 Title::lastPlayedTimestamp(void) { - return mLastPlayedTimestamp; -} - -void Title::lastPlayedTimestamp(u32 lastPlayedTimestamp) { - mLastPlayedTimestamp = lastPlayedTimestamp; -} - -void Title::refreshDirectories(void) { - mSaves.clear(); - mFullSavePaths.clear(); - - Directory savelist(mPath); + Directory savelist(m_path); if (savelist.good()) { - for (size_t i = 0, sz = savelist.size(); i < sz; i++) { + for (size_t i = 0; i < savelist.size(); ++i) { if (savelist.folder(i)) { - mSaves.push_back(savelist.entry(i)); - mFullSavePaths.push_back(mPath + "/" + savelist.entry(i)); + m_saves.push_back(savelist.entry(i)); + m_full_save_paths.push_back(m_path + "/" + savelist.entry(i)); } } - - std::sort(mSaves.rbegin(), mSaves.rend()); - std::sort(mFullSavePaths.rbegin(), mFullSavePaths.rend()); - mSaves.insert(mSaves.begin(), g_emptySave); - mFullSavePaths.insert(mFullSavePaths.begin(), g_emptySave); + std::sort(m_saves.rbegin(), m_saves.rend()); + std::sort(m_full_save_paths.rbegin(), m_full_save_paths.rend()); + m_saves.insert(m_saves.begin(), kEmptySave); + m_full_save_paths.insert(m_full_save_paths.begin(), kEmptySave); } else { - Logger::getInstance().log(Logger::ERROR, - "Couldn't retrieve the extdata directory list for the title " + name()); + nxst::log::error("Could not read save directory for title %s", m_name.c_str()); } } -void loadTitles(void) { - if (s_titlesLoaded) - return; - s_titlesLoaded = true; +bool areTitlesLoaded() { + return s_titles_loaded; +} +void loadTitles() { + if (s_titles_loaded) + return; + s_titles_loaded = true; titles.clear(); FsSaveDataInfoReader reader; - FsSaveDataInfo info; - s64 total_entries = 0; - size_t outsize = 0; - - NacpLanguageEntry* nle = NULL; - NsApplicationControlData* nsacd = (NsApplicationControlData*)malloc(sizeof(NsApplicationControlData)); - if (nsacd == NULL) { - return; - } - memset(nsacd, 0, sizeof(NsApplicationControlData)); - Result res = fsOpenSaveDataInfoReader(&reader, FsSaveDataSpaceId_User); - if (R_FAILED(res)) { - free(nsacd); + if (R_FAILED(res)) return; - } - while (1) { - res = fsSaveDataInfoReaderRead(&reader, &info, 1, &total_entries); - if (R_FAILED(res) || total_entries == 0) { + std::vector<u8> nacp_buf(sizeof(NsApplicationControlData), 0); + auto* nsacd = reinterpret_cast<NsApplicationControlData*>(nacp_buf.data()); + + FsSaveDataInfo info{}; + s64 count = 0; + while (true) { + res = fsSaveDataInfoReaderRead(&reader, &info, 1, &count); + if (R_FAILED(res) || count == 0) break; + if (info.save_data_type != FsSaveDataType_Account) + continue; + + u64 tid = info.application_id; + AccountUid uid = info.uid; + size_t outsize = 0; + NacpLanguageEntry* nle = nullptr; + + memset(nsacd, 0, sizeof(NsApplicationControlData)); + res = nsGetApplicationControlData(NsApplicationControlSource_Storage, tid, nsacd, + sizeof(NsApplicationControlData), &outsize); + if (R_FAILED(res) || outsize < sizeof(nsacd->nacp)) + continue; + if (R_FAILED(nacpGetLanguageEntry(&nsacd->nacp, &nle)) || !nle) + continue; + + Title title; + title.init(info.save_data_type, tid, uid, std::string(nle->name), std::string(nle->author)); + title.saveId(info.save_data_id); + + PdmPlayStatistics stats{}; + if (R_SUCCEEDED(pdmqryQueryPlayStatisticsByApplicationIdAndUserAccountId(tid, uid, false, &stats))) { + title.playTimeNanoseconds(stats.playtime); + title.lastPlayedTimestamp(stats.last_timestamp_user); } - if (info.save_data_type == FsSaveDataType_Account) { - u64 tid = info.application_id; - u64 sid = info.save_data_id; - AccountUid uid = info.uid; - // if (mFilterIds.find(tid) == mFilterIds.end()) { - res = nsGetApplicationControlData(NsApplicationControlSource_Storage, tid, nsacd, - sizeof(NsApplicationControlData), &outsize); - if (R_SUCCEEDED(res) && !(outsize < sizeof(nsacd->nacp))) { - res = nacpGetLanguageEntry(&nsacd->nacp, &nle); - if (R_SUCCEEDED(res) && nle != NULL) { - Title title; - title.init(info.save_data_type, tid, uid, std::string(nle->name), - std::string(nle->author)); - title.saveId(sid); - - // load play statistics - PdmPlayStatistics stats; - res = pdmqryQueryPlayStatisticsByApplicationIdAndUserAccountId(tid, uid, false, &stats); - if (R_SUCCEEDED(res)) { - title.playTimeNanoseconds(stats.playtime); - title.lastPlayedTimestamp(stats.last_timestamp_user); - } - - // loadIcon(tid, nsacd, outsize - sizeof(nsacd->nacp)); - - // check if the vector is already created - std::unordered_map<AccountUid, std::vector<Title>>::iterator it = titles.find(uid); - if (it != titles.end()) { - // found - it->second.push_back(title); - } else { - // not found, insert into map - std::vector<Title> v; - v.push_back(title); - titles.emplace(uid, v); - } - } - } - nle = NULL; - // } + auto it = titles.find(uid); + if (it != titles.end()) { + it->second.push_back(title); + } else { + titles.emplace(uid, std::vector<Title>{title}); } } - free(nsacd); fsSaveDataInfoReaderClose(&reader); - sortTitles(); } -void sortTitles(void) { - for (auto& vect : titles) { - std::sort(vect.second.begin(), vect.second.end(), [](Title& l, Title& r) { - switch (g_sortMode) { - case SORT_LAST_PLAYED: +void sortTitles() { + for (auto& pair : titles) { + std::sort(pair.second.begin(), pair.second.end(), [](const Title& l, const Title& r) { + switch (s_sort_mode) { + case SortLastPlayed: return l.lastPlayedTimestamp() > r.lastPlayedTimestamp(); - case SORT_PLAY_TIME: + case SortPlayTime: return l.playTimeNanoseconds() > r.playTimeNanoseconds(); - case SORT_ALPHA: + case SortAlpha: default: return l.name() < r.name(); } @@ -262,38 +208,36 @@ void sortTitles(void) { } } -void rotateSortMode(void) { - g_sortMode = static_cast<sort_t>((g_sortMode + 1) % SORT_MODES_COUNT); +void rotateSortMode() { + s_sort_mode = static_cast<sort_t>((s_sort_mode + 1) % SortModesCount); sortTitles(); } void getTitle(Title& dst, AccountUid uid, size_t i) { - std::unordered_map<AccountUid, std::vector<Title>>::iterator it = titles.find(uid); - if (it != titles.end() && i < getTitleCount(uid)) { - dst = it->second.at(i); - } + auto it = titles.find(uid); + if (it != titles.end() && i < it->second.size()) + dst = it->second[i]; } size_t getTitleCount(AccountUid uid) { - std::unordered_map<AccountUid, std::vector<Title>>::iterator it = titles.find(uid); + auto it = titles.find(uid); return it != titles.end() ? it->second.size() : 0; } void refreshDirectories(u64 id) { for (auto& pair : titles) { - for (size_t i = 0; i < pair.second.size(); i++) { - if (pair.second.at(i).id() == id) { - pair.second.at(i).refreshDirectories(); - } + for (auto& title : pair.second) { + if (title.id() == id) + title.refreshDirectories(); } } } -std::unordered_map<std::string, std::string> getCompleteTitleList(void) { +std::unordered_map<std::string, std::string> getCompleteTitleList() { std::unordered_map<std::string, std::string> map; for (const auto& pair : titles) { - for (auto value : pair.second) { - map.insert({StringUtils::format("0x%016llX", value.id()), value.name()}); + for (const auto& title : pair.second) { + map.emplace(string_utils::format("0x%016llX", title.id()), title.name()); } } return map; diff --git a/src/domain/util.cpp b/src/domain/util.cpp index dd7d601..80d4f30 100644 --- a/src/domain/util.cpp +++ b/src/domain/util.cpp @@ -1,159 +1,250 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ +// Copyright (C) 2024-2026 NXST contributors +#include <algorithm> +#include <cctype> +#include <cstdarg> +#include <cstdio> +#include <string> +#include <unordered_map> -#include <nxst/app/main.hpp> -#include <nxst/app/main_application.hpp> +#include <nxst/domain/account.hpp> #include <nxst/domain/util.hpp> +#include <nxst/infra/fs/io.hpp> #include <nxst/infra/sys/logger.hpp> -void servicesExit(void) { - Logger::getInstance().flush(); - Account::exit(); +static bool s_notification_led_available = false; + +void servicesExit() { + account::exit(); plExit(); romfsExit(); } -Result servicesInit(void) { +Result servicesInit() { io::createDirectory("sdmc:/switch"); io::createDirectory("sdmc:/switch/NXST"); io::createDirectory("sdmc:/switch/NXST/saves"); if (appletGetAppletType() != AppletType_Application) { - Logger::getInstance().log(Logger::WARN, "Please do not run NXST in applet mode."); + nxst::log::warn("Please do not run NXST in applet mode."); } Result res = 0; - romfsInit(); - padConfigureInput(1, HidNpadStyleSet_NpadStandard); hidInitializeTouchScreen(); if (R_FAILED(res = plInitialize(PlServiceType_User))) { - Logger::getInstance().log(Logger::ERROR, "plInitialize failed. Result code 0x%08lX.", res); + nxst::log::error("plInitialize failed. Result code 0x%08X.", res); return res; } - - if (R_FAILED(res = Account::init())) { - Logger::getInstance().log(Logger::ERROR, "Account::init failed. Result code 0x%08lX.", res); + if (R_FAILED(res = account::init())) { + nxst::log::error("account::init failed. Result code 0x%08X.", res); return res; } - if (R_FAILED(res = nsInitialize())) { - Logger::getInstance().log(Logger::ERROR, "nsInitialize failed. Result code 0x{:08X}.", res); + nxst::log::error("nsInitialize failed. Result code 0x%08X.", res); return res; } - - if (R_SUCCEEDED(res = hidsysInitialize())) { - g_notificationLedAvailable = true; + if (R_SUCCEEDED(hidsysInitialize())) { + s_notification_led_available = true; } else { - Logger::getInstance().log(Logger::INFO, "Notification led not available. Result code 0x{:08X}.", res); + nxst::log::info("Notification LED not available."); } - Logger::getInstance().log(Logger::INFO, "NXST loading completed!"); - + nxst::log::info("NXST loading completed."); return 0; } -std::u16string StringUtils::UTF8toUTF16(const char* src) { - char16_t tmp[256] = {0}; - utf8_to_utf16((uint16_t*)tmp, (uint8_t*)src, 256); - return std::u16string(tmp); +bool string_utils::containsInvalidChar(const std::string& str) { + for (unsigned char c : str) { + if (!isascii(c)) + return true; + } + return false; } -// https://stackoverflow.com/questions/14094621/change-all-accented-letters-to-normal-letters-in-c -std::string StringUtils::removeAccents(std::string str) { - std::u16string src = UTF8toUTF16(str.c_str()); - const std::u16string illegal = - UTF8toUTF16("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüūýþÿ"); - const std::u16string fixed = - UTF8toUTF16("AAAAAAECEEEEIIIIDNOOOOOx0UUUUYPsaaaaaaeceeeeiiiiOnooooo/0uuuuuypy"); +std::string string_utils::format(const char* fmt, ...) { + va_list a1, a2; + va_start(a1, fmt); + va_copy(a2, a1); + int n = vsnprintf(nullptr, 0, fmt, a1); + va_end(a1); + if (n < 0) { + va_end(a2); + return {}; + } + std::string buf(static_cast<size_t>(n), '\0'); + vsnprintf(buf.data(), static_cast<size_t>(n) + 1, fmt, a2); + va_end(a2); + return buf; +} - for (size_t i = 0, sz = src.length(); i < sz; i++) { - size_t index = illegal.find(src[i]); - if (index != std::string::npos) { - src[i] = fixed[index]; +std::string string_utils::removeForbiddenCharacters(std::string src) { + static constexpr std::string_view kForbidden = ".,!\\/:?*\"<>|"; + for (char& c : src) { + if (kForbidden.find(c) != std::string_view::npos) + c = ' '; + } + auto last = src.find_last_not_of(' '); + if (last != std::string::npos) + src.erase(last + 1); + return src; +} + +static size_t encodeUtf8(char* out, char32_t cp) { + if (cp < 0x80) { + out[0] = static_cast<char>(cp); + return 1; + } + if (cp < 0x800) { + out[0] = static_cast<char>(0xC0 | (cp >> 6)); + out[1] = static_cast<char>(0x80 | (cp & 0x3F)); + return 2; + } + if (cp < 0x10000) { + out[0] = static_cast<char>(0xE0 | (cp >> 12)); + out[1] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F)); + out[2] = static_cast<char>(0x80 | (cp & 0x3F)); + return 3; + } + out[0] = static_cast<char>(0xF0 | (cp >> 18)); + out[1] = static_cast<char>(0x80 | ((cp >> 12) & 0x3F)); + out[2] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F)); + out[3] = static_cast<char>(0x80 | (cp & 0x3F)); + return 4; +} + +std::string string_utils::UTF16toUTF8(const std::u16string& src) { + std::string result; + result.reserve(src.size() * 2); + for (size_t i = 0; i < src.size(); ++i) { + char32_t cp = src[i]; + if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < src.size()) { + cp = 0x10000 + ((cp - 0xD800) << 10) + (src[++i] - 0xDC00); + } + char buf[4]; + result.append(buf, encodeUtf8(buf, cp)); + } + return result; +} + +void string_utils::ltrim(std::string& s) { + s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char c) { + return !std::isspace(c); + })); +} + +void string_utils::rtrim(std::string& s) { + s.erase(std::find_if(s.rbegin(), s.rend(), + [](unsigned char c) { + return !std::isspace(c); + }) + .base(), + s.end()); +} + +void string_utils::trim(std::string& s) { + ltrim(s); + rtrim(s); +} + +// Decodes a UTF-8 string to UTF-16, handling surrogate pairs for codepoints > U+FFFF. +std::u16string string_utils::UTF8toUTF16(const char* src) { + std::u16string result; + while (*src != '\0') { + char32_t cp = 0; + unsigned char c = static_cast<unsigned char>(*src); + if (c < 0x80) { + cp = c; + ++src; + } else if (c < 0xE0) { + cp = static_cast<char32_t>(c & 0x1F) << 6 | (src[1] & 0x3F); + src += 2; + } else if (c < 0xF0) { + cp = static_cast<char32_t>(c & 0x0F) << 12 | static_cast<char32_t>(src[1] & 0x3F) << 6 | + (src[2] & 0x3F); + src += 3; + } else { + cp = static_cast<char32_t>(c & 0x07) << 18 | static_cast<char32_t>(src[1] & 0x3F) << 12 | + static_cast<char32_t>(src[2] & 0x3F) << 6 | (src[3] & 0x3F); + src += 4; + } + if (cp < 0x10000) { + result += static_cast<char16_t>(cp); + } else { + cp -= 0x10000; + result += static_cast<char16_t>(0xD800 | (cp >> 10)); + result += static_cast<char16_t>(0xDC00 | (cp & 0x3FF)); } } - - return UTF16toUTF8(src); + return result; } -std::string StringUtils::removeNotAscii(std::string str) { - for (size_t i = 0, sz = str.length(); i < sz; i++) { - if (!isascii(str[i])) { - str[i] = ' '; - } +// Replaces Latin characters with diacritics with their ASCII base equivalents. +std::string string_utils::removeAccents(std::string str) { + static const std::unordered_map<char16_t, char16_t> kMap = { + {u'À', u'A'}, {u'Á', u'A'}, {u'Â', u'A'}, {u'Ã', u'A'}, {u'Ä', u'A'}, {u'Å', u'A'}, {u'Æ', u'E'}, + {u'Ç', u'C'}, {u'È', u'E'}, {u'É', u'E'}, {u'Ê', u'E'}, {u'Ë', u'E'}, {u'Ì', u'I'}, {u'Í', u'I'}, + {u'Î', u'I'}, {u'Ï', u'I'}, {u'Ð', u'D'}, {u'Ñ', u'N'}, {u'Ò', u'O'}, {u'Ó', u'O'}, {u'Ô', u'O'}, + {u'Õ', u'O'}, {u'Ö', u'O'}, {u'Ø', u'O'}, {u'Ù', u'U'}, {u'Ú', u'U'}, {u'Û', u'U'}, {u'Ü', u'U'}, + {u'Ý', u'Y'}, {u'ß', u's'}, {u'à', u'a'}, {u'á', u'a'}, {u'â', u'a'}, {u'ã', u'a'}, {u'ä', u'a'}, + {u'å', u'a'}, {u'æ', u'e'}, {u'ç', u'c'}, {u'è', u'e'}, {u'é', u'e'}, {u'ê', u'e'}, {u'ë', u'e'}, + {u'ì', u'i'}, {u'í', u'i'}, {u'î', u'i'}, {u'ï', u'i'}, {u'ñ', u'n'}, {u'ò', u'o'}, {u'ó', u'o'}, + {u'ô', u'o'}, {u'õ', u'o'}, {u'ö', u'o'}, {u'ø', u'o'}, {u'ù', u'u'}, {u'ú', u'u'}, {u'û', u'u'}, + {u'ü', u'u'}, {u'ū', u'u'}, {u'ý', u'y'}, {u'ÿ', u'y'}, + }; + std::u16string wide = UTF8toUTF16(str.c_str()); + for (char16_t& ch : wide) { + auto it = kMap.find(ch); + if (it != kMap.end()) + ch = it->second; + } + return string_utils::UTF16toUTF8(wide); +} + +std::string string_utils::removeNotAscii(std::string str) { + for (char& c : str) { + if (!isascii(static_cast<unsigned char>(c))) + c = ' '; } return str; } -std::string StringUtils::elide(const std::string& s, size_t maxChars) { - if (s.size() <= maxChars || maxChars < 6) +std::string string_utils::elide(const std::string& s, size_t max_chars) { + if (s.size() <= max_chars || max_chars < 6) return s; - constexpr const char* dots = "..."; - size_t budget = maxChars - 3; + size_t budget = max_chars - 3; size_t head = (budget + 1) / 2; size_t tail = budget - head; - return s.substr(0, head) + dots + s.substr(s.size() - tail); + return s.substr(0, head) + "..." + s.substr(s.size() - tail); } -HidsysNotificationLedPattern blinkLedPattern(u8 times) { - HidsysNotificationLedPattern pattern; - memset(&pattern, 0, sizeof(pattern)); - - pattern.baseMiniCycleDuration = 0x1; // 12.5ms. - pattern.totalMiniCycles = 0x2; // 2 mini cycles. - pattern.totalFullCycles = times; // Repeat n times. - pattern.startIntensity = 0x0; // 0%. - - pattern.miniCycles[0].ledIntensity = 0xF; // 100%. - pattern.miniCycles[0].transitionSteps = 0xF; // 15 steps. Total 187.5ms. - pattern.miniCycles[0].finalStepDuration = 0x0; // Forced 12.5ms. - pattern.miniCycles[1].ledIntensity = 0x0; // 0%. - pattern.miniCycles[1].transitionSteps = 0xF; // 15 steps. Total 187.5ms. - pattern.miniCycles[1].finalStepDuration = 0x0; // Forced 12.5ms. - - return pattern; +static HidsysNotificationLedPattern makeLedPattern(u8 times) { + HidsysNotificationLedPattern p{}; + p.baseMiniCycleDuration = 0x1; + p.totalMiniCycles = 0x2; + p.totalFullCycles = times; + p.startIntensity = 0x0; + p.miniCycles[0] = {0xF, 0xF, 0x0}; + p.miniCycles[1] = {0x0, 0xF, 0x0}; + return p; } void blinkLed(u8 times) { - if (g_notificationLedAvailable) { - PadState pad; - padInitializeDefault(&pad); - s32 n; - HidsysUniquePadId uniquePadIds[2] = {0}; - HidsysNotificationLedPattern pattern = blinkLedPattern(times); - memset(uniquePadIds, 0, sizeof(uniquePadIds)); - Result res = hidsysGetUniquePadsFromNpad( - padIsHandheld(&pad) ? HidNpadIdType_Handheld : HidNpadIdType_No1, uniquePadIds, 2, &n); - if (R_SUCCEEDED(res)) { - for (s32 i = 0; i < n; i++) { - hidsysSetNotificationLedPattern(&pattern, uniquePadIds[i]); - } + if (!s_notification_led_available) + return; + + PadState pad; + padInitializeDefault(&pad); + s32 n = 0; + HidsysUniquePadId pads[2]{}; + HidsysNotificationLedPattern pattern = makeLedPattern(times); + + Result res = hidsysGetUniquePadsFromNpad(padIsHandheld(&pad) ? HidNpadIdType_Handheld : HidNpadIdType_No1, + pads, 2, &n); + if (R_SUCCEEDED(res)) { + for (s32 i = 0; i < n; ++i) { + hidsysSetNotificationLedPattern(&pattern, pads[i]); } } } diff --git a/src/infra/fs/directory.cpp b/src/infra/fs/directory.cpp index d5e4507..d551179 100644 --- a/src/infra/fs/directory.cpp +++ b/src/infra/fs/directory.cpp @@ -1,69 +1,27 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ +// Copyright (C) 2024-2026 NXST contributors +#include <cerrno> +#include <dirent.h> #include <nxst/infra/fs/directory.hpp> -Directory::Directory(const std::string& root) { - mGood = false; - mError = 0; - mList.clear(); - - DIR* dir = opendir(root.c_str()); - struct dirent* ent; - - if (dir == NULL) { - mError = (Result)errno; - } else { - while ((ent = readdir(dir))) { - std::string name = std::string(ent->d_name); - bool directory = ent->d_type == DT_DIR; - struct DirectoryEntry de = {name, directory}; - mList.push_back(de); - } - closedir(dir); - mGood = true; +Directory::Directory(const std::string& path) { + DIR* d = opendir(path.c_str()); + if (!d) { + m_error = static_cast<Result>(errno); + return; } + struct dirent* ent; + while ((ent = readdir(d)) != nullptr) { + m_entries.push_back({ent->d_name, ent->d_type == DT_DIR}); + } + closedir(d); + m_good = true; } -Result Directory::error(void) { - return mError; +std::string Directory::entry(size_t i) const { + return i < m_entries.size() ? m_entries[i].name : ""; } -bool Directory::good(void) { - return mGood; +bool Directory::folder(size_t i) const { + return i < m_entries.size() && m_entries[i].is_dir; } - -std::string Directory::entry(size_t index) { - return index < mList.size() ? mList.at(index).name : ""; -} - -bool Directory::folder(size_t index) { - return index < mList.size() ? mList.at(index).directory : false; -} - -size_t Directory::size(void) { - return mList.size(); -} \ No newline at end of file diff --git a/src/infra/fs/filesystem.cpp b/src/infra/fs/filesystem.cpp index 69138f1..9abd9ea 100644 --- a/src/infra/fs/filesystem.cpp +++ b/src/infra/fs/filesystem.cpp @@ -1,39 +1,14 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors #include <nxst/infra/fs/filesystem.hpp> -Result FileSystem::mount(FsFileSystem* fileSystem, u64 titleID, AccountUid userID) { - return fsOpen_SaveData(fileSystem, titleID, userID); +Result file_system::mount(FsFileSystem* fs, u64 title_id, AccountUid uid) { + return fsOpen_SaveData(fs, title_id, uid); } -int FileSystem::mount(FsFileSystem fs) { +int file_system::mount(FsFileSystem fs) { return fsdevMountDevice("save", fs); } -void FileSystem::unmount(void) { +void file_system::unmount() { fsdevUnmountDevice("save"); -} \ No newline at end of file +} diff --git a/src/infra/fs/io.cpp b/src/infra/fs/io.cpp index 9c86721..e13164f 100644 --- a/src/infra/fs/io.cpp +++ b/src/infra/fs/io.cpp @@ -1,56 +1,36 @@ -/* - * This file is part of Checkpoint - * Copyright (C) 2017-2021 Bernardo Giordano, FlagBrew - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see <http://www.gnu.org/licenses/>. - * - * Additional Terms 7.b and 7.c of GPLv3 apply to this file: - * * Requiring preservation of specified reasonable legal notices or - * author attributions in that material or in the Appropriate Legal - * Notices displayed by works containing it. - * * Prohibiting misrepresentation of the origin of that material, - * or requiring that modified versions of such material be marked in - * reasonable ways as different from the original version. - */ - +// Copyright (C) 2024-2026 NXST contributors +#include <cstdio> +#include <sys/stat.h> +#include <unistd.h> #include <vector> -#include <nxst/app/main.hpp> +#include <nxst/domain/account.hpp> +#include <nxst/domain/title.hpp> +#include <nxst/domain/util.hpp> +#include <nxst/infra/fs/directory.hpp> +#include <nxst/infra/fs/filesystem.hpp> #include <nxst/infra/fs/handles.hpp> #include <nxst/infra/fs/io.hpp> #include <nxst/infra/sys/logger.hpp> +static constexpr size_t kBufSize = 0x80000; + bool io::fileExists(const std::string& path) { struct stat buffer; return (stat(path.c_str(), &buffer) == 0); } void io::copyFile(const std::string& srcPath, const std::string& dstPath) { - g_isTransferringFile = true; - nxst::FileHandle src(fopen(srcPath.c_str(), "rb")); if (!src) { nxst::log::error("Failed to open source file %s during copy with errno %d. Skipping...", srcPath.c_str(), errno); - g_isTransferringFile = false; return; } nxst::FileHandle dst(fopen(dstPath.c_str(), "wb")); if (!dst) { nxst::log::error("Failed to open destination file %s during copy with errno %d. Skipping...", dstPath.c_str(), errno); - g_isTransferringFile = false; return; } @@ -58,28 +38,28 @@ void io::copyFile(const std::string& srcPath, const std::string& dstPath) { u64 sz = (u64)ftell(src.get()); rewind(src.get()); - std::vector<u8> buf(BUFFER_SIZE); + std::vector<u8> buf(kBufSize); u64 offset = 0; - size_t slashpos = srcPath.rfind('/'); - g_currentFile = srcPath.substr(slashpos + 1, srcPath.length() - slashpos - 1); - while (offset < sz) { - u32 count = (u32)fread(buf.data(), 1, BUFFER_SIZE, src.get()); + u32 count = (u32)fread(buf.data(), 1, kBufSize, src.get()); if (count == 0) { nxst::log::error("fread returned 0 for %s at offset %llu/%llu (errno %d). Aborting.", srcPath.c_str(), (unsigned long long)offset, (unsigned long long)sz, errno); break; } - fwrite(buf.data(), 1, count, dst.get()); + size_t written = fwrite(buf.data(), 1, count, dst.get()); + if (written != count) { + nxst::log::error("fwrite incomplete for %s (%zu/%u bytes). Aborting.", dstPath.c_str(), written, + count); + break; + } offset += count; } if (dstPath.rfind("save:/", 0) == 0) { fsdevCommitDevice("save"); } - - g_isTransferringFile = false; } Result io::copyDirectory(const std::string& srcPath, const std::string& dstPath) { @@ -96,24 +76,27 @@ Result io::copyDirectory(const std::string& srcPath, const std::string& dstPath) std::string newdst = dstPath + items.entry(i); if (items.folder(i)) { - res = io::createDirectory(newdst); + res = createDirectory(newdst); if (R_SUCCEEDED(res)) { newsrc += "/"; newdst += "/"; - res = io::copyDirectory(newsrc, newdst); + res = copyDirectory(newsrc, newdst); } else { quit = true; } } else { - io::copyFile(newsrc, newdst); + copyFile(newsrc, newdst); } } - return 0; + return res; } Result io::createDirectory(const std::string& path) { - mkdir(path.c_str(), 0777); + if (mkdir(path.c_str(), 0777) != 0 && errno != EEXIST) { + nxst::log::error("mkdir failed for %s (errno %d).", path.c_str(), errno); + return 1; + } return 0; } @@ -128,20 +111,21 @@ Result io::deleteFolderRecursively(const std::string& path) { return dir.error(); } + Result res = 0; for (size_t i = 0, sz = dir.size(); i < sz; i++) { if (dir.folder(i)) { - std::string newpath = path + "/" + dir.entry(i) + "/"; - deleteFolderRecursively(newpath); - newpath = path + dir.entry(i); - rmdir(newpath.c_str()); + std::string sub = path + "/" + dir.entry(i); + Result sub_res = deleteFolderRecursively(sub + "/"); + if (R_FAILED(sub_res)) + res = sub_res; + rmdir(sub.c_str()); } else { - std::string newpath = path + dir.entry(i); - std::remove(newpath.c_str()); + std::remove((path + dir.entry(i)).c_str()); } } rmdir(path.c_str()); - return 0; + return res; } nxst::Result<std::string> io::backup(size_t index, AccountUid uid) { @@ -151,54 +135,61 @@ nxst::Result<std::string> io::backup(size_t index, AccountUid uid) { nxst::log::info("Started backup of %s. Title id: 0x%016lX; User id: 0x%lX%lX.", title.name().c_str(), title.id(), title.userId().uid[1], title.userId().uid[0]); - nxst::FsFileSystemHandle fsHandle; - Result res = FileSystem::mount(fsHandle.get(), title.id(), title.userId()); + nxst::FsFileSystemHandle fs_handle; + Result res = file_system::mount(fs_handle.get(), title.id(), title.userId()); if (R_FAILED(res)) { - nxst::log::error("Failed to mount filesystem during backup with result 0x%08lX. " + nxst::log::error("Failed to mount filesystem during backup with result 0x%08X. " "Title id: 0x%016lX; User id: 0x%lX%lX.", res, title.id(), title.userId().uid[1], title.userId().uid[0]); return nxst::Result<std::string>::failure("Failed to mount save."); } - fsHandle.valid = true; + fs_handle.valid = true; - if (FileSystem::mount(*fsHandle.get()) == -1) { + if (file_system::mount(*fs_handle.get()) == -1) { nxst::log::error("Failed to mount devfs during backup. Title id: 0x%016lX; User id: 0x%lX%lX.", title.id(), title.userId().uid[1], title.userId().uid[0]); - FileSystem::unmount(); + file_system::unmount(); return nxst::Result<std::string>::failure("Failed to mount save."); } - fsHandle.release(); // devfs now owns the kernel handle + fs_handle.release(); // devfs now owns the kernel handle std::string suggestion = - StringUtils::removeNotAscii(StringUtils::removeAccents(Account::username(title.userId()))); + string_utils::removeNotAscii(string_utils::removeAccents(account::username(title.userId()))); io::createDirectory(title.path()); std::string dst_path = title.path() + "/" + suggestion; std::string tmp_path = dst_path + ".tmp"; if (io::directoryExists(tmp_path)) { - io::deleteFolderRecursively(tmp_path + "/"); + if (R_FAILED(io::deleteFolderRecursively(tmp_path + "/"))) + nxst::log::warn("Failed to clean up stale tmp dir %s.", tmp_path.c_str()); } - io::createDirectory(tmp_path); - res = io::copyDirectory("save:/", tmp_path + "/"); + res = io::createDirectory(tmp_path); if (R_FAILED(res)) { - FileSystem::unmount(); + file_system::unmount(); + nxst::log::error("Failed to create tmp dir %s.", tmp_path.c_str()); + return nxst::Result<std::string>::failure("Failed to create tmp directory."); + } + res = copyDirectory("save:/", tmp_path + "/"); + if (R_FAILED(res)) { + file_system::unmount(); io::deleteFolderRecursively(tmp_path + "/"); - nxst::log::error("Failed to copy directory to %s with result 0x%08lX.", tmp_path.c_str(), res); + nxst::log::error("Failed to copy directory to %s with result 0x%08X.", tmp_path.c_str(), res); return nxst::Result<std::string>::failure("Failed to backup save."); } if (io::directoryExists(dst_path)) { - io::deleteFolderRecursively(dst_path + "/"); + if (R_FAILED(io::deleteFolderRecursively(dst_path + "/"))) + nxst::log::warn("Failed to remove old backup at %s.", dst_path.c_str()); } if (rename(tmp_path.c_str(), dst_path.c_str()) != 0) { - FileSystem::unmount(); + file_system::unmount(); nxst::log::error("Failed to rename temp backup to %s.", dst_path.c_str()); return nxst::Result<std::string>::failure("Failed to finalise backup."); } refreshDirectories(title.id()); - FileSystem::unmount(); + file_system::unmount(); nxst::log::info("Backup succeeded."); return nxst::Result<std::string>::success(dst_path); @@ -246,7 +237,7 @@ static nxst::Result<void> clearSaveRoot(const std::string& dst_path) { Result res = fsdevCommitDevice("save"); if (R_FAILED(res)) { - nxst::log::error("Failed to commit save after clearing with result 0x%08lX.", res); + nxst::log::error("Failed to commit save after clearing with result 0x%08X.", res); return nxst::Result<void>::failure("Failed to commit save after delete."); } return nxst::Result<void>::success(); @@ -255,22 +246,19 @@ static nxst::Result<void> clearSaveRoot(const std::string& dst_path) { static nxst::Result<void> extractAndCommit(const std::string& src_path, const std::string& dst_path) { Result res = io::copyDirectory(src_path, dst_path); if (R_FAILED(res)) { - nxst::log::error("Failed to copy %s to save:/ with result 0x%08lX.", src_path.c_str(), res); + nxst::log::error("Failed to copy %s to save:/ with result 0x%08X.", src_path.c_str(), res); return nxst::Result<void>::failure("Failed to restore save."); } res = fsdevCommitDevice("save"); if (R_FAILED(res)) { - nxst::log::error("Failed to commit save with result 0x%08lX.", res); + nxst::log::error("Failed to commit save with result 0x%08X.", res); return nxst::Result<void>::failure("Failed to commit to save device."); } return nxst::Result<void>::success(); } -nxst::Result<std::string> io::restore(size_t index, AccountUid uid, size_t cellIndex, - const std::string& nameFromCell) { - (void)cellIndex; - +nxst::Result<std::string> io::restore(size_t index, AccountUid uid, const std::string& title_name) { Title title; getTitle(title, uid, index); @@ -279,32 +267,32 @@ nxst::Result<std::string> io::restore(size_t index, AccountUid uid, size_t cellI createSaveIfNeeded(title.id(), uid); - nxst::FsFileSystemHandle fsHandle; - Result res = FileSystem::mount(fsHandle.get(), title.id(), uid); + nxst::FsFileSystemHandle fs_handle; + Result res = file_system::mount(fs_handle.get(), title.id(), uid); if (R_FAILED(res)) { - nxst::log::error("Failed to mount filesystem during restore with result 0x%08lX. " + nxst::log::error("Failed to mount filesystem during restore with result 0x%08X. " "Title id: 0x%016lX; User id: 0x%lX%lX.", res, title.id(), uid.uid[1], uid.uid[0]); return nxst::Result<std::string>::failure("Failed to mount save."); } - fsHandle.valid = true; + fs_handle.valid = true; - if (FileSystem::mount(*fsHandle.get()) == -1) { + if (file_system::mount(*fs_handle.get()) == -1) { nxst::log::error("Failed to mount devfs during restore. Title id: 0x%016lX; User id: 0x%lX%lX.", title.id(), uid.uid[1], uid.uid[0]); - FileSystem::unmount(); + file_system::unmount(); return nxst::Result<std::string>::failure("Failed to mount save."); } - fsHandle.release(); // devfs now owns the kernel handle + fs_handle.release(); // devfs now owns the kernel handle - std::string suggestion = StringUtils::removeNotAscii(StringUtils::removeAccents(Account::username(uid))); + std::string suggestion = string_utils::removeNotAscii(string_utils::removeAccents(account::username(uid))); std::string src_path = title.path() + "/" + suggestion + "/"; const std::string dst_path = "save:/"; { Directory src_check(src_path); if (!src_check.good() || src_check.size() == 0) { - FileSystem::unmount(); + file_system::unmount(); nxst::log::error("Restore source is empty or missing: %s", src_path.c_str()); return nxst::Result<std::string>::failure("Restore source is empty or missing."); } @@ -312,19 +300,19 @@ nxst::Result<std::string> io::restore(size_t index, AccountUid uid, size_t cellI auto clear_res = clearSaveRoot(dst_path); if (!clear_res.isOk()) { - FileSystem::unmount(); + file_system::unmount(); return nxst::Result<std::string>::failure(clear_res.error()); } auto extract_res = extractAndCommit(src_path, dst_path); if (!extract_res.isOk()) { - FileSystem::unmount(); + file_system::unmount(); return nxst::Result<std::string>::failure(extract_res.error()); } blinkLed(4); - FileSystem::unmount(); + file_system::unmount(); nxst::log::info("Restore succeeded."); - return nxst::Result<std::string>::success(nameFromCell + "\nhas been restored successfully."); + return nxst::Result<std::string>::success(title_name + "\nhas been restored successfully."); } diff --git a/src/infra/net/transfer_receiver.cpp b/src/infra/net/transfer_receiver.cpp deleted file mode 100644 index bfd75ba..0000000 --- a/src/infra/net/transfer_receiver.cpp +++ /dev/null @@ -1 +0,0 @@ -// Logic moved to src/service/transfer_service.cpp diff --git a/src/infra/net/transfer_sender.cpp b/src/infra/net/transfer_sender.cpp deleted file mode 100644 index bfd75ba..0000000 --- a/src/infra/net/transfer_sender.cpp +++ /dev/null @@ -1 +0,0 @@ -// Logic moved to src/service/transfer_service.cpp diff --git a/src/infra/sys/logger.cpp b/src/infra/sys/logger.cpp index 7e61d9f..985dea8 100644 --- a/src/infra/sys/logger.cpp +++ b/src/infra/sys/logger.cpp @@ -7,84 +7,84 @@ namespace { -std::mutex g_log_mutex; + std::mutex g_log_mutex; #if defined(__SWITCH__) -constexpr const char* kLogPath = "/switch/NXST/log.log"; + constexpr const char* kLogPath = "/switch/NXST/log.log"; #else -constexpr const char* kLogPath = "nxst.log"; + constexpr const char* kLogPath = "nxst.log"; #endif -void writeEntry(const char* tag, const char* fmt, va_list args) { - char msg[2048]; - vsnprintf(msg, sizeof(msg), fmt, args); + void writeEntry(const char* tag, const char* fmt, va_list args) { + char msg[2048]; + vsnprintf(msg, sizeof(msg), fmt, args); - time_t now = time(nullptr); - struct tm tm_buf; - localtime_r(&now, &tm_buf); - char time_str[16]; - strftime(time_str, sizeof(time_str), "%H:%M:%S", &tm_buf); + time_t now = time(nullptr); + struct tm tm_buf; + localtime_r(&now, &tm_buf); + char time_str[16]; + strftime(time_str, sizeof(time_str), "%H:%M:%S", &tm_buf); - std::lock_guard<std::mutex> lock(g_log_mutex); + std::lock_guard<std::mutex> lock(g_log_mutex); - fprintf(stderr, "[%s]%s %s\n", time_str, tag, msg); + fprintf(stderr, "[%s]%s %s\n", time_str, tag, msg); - FILE* log_file = fopen(kLogPath, "a"); - if (log_file != nullptr) { - fprintf(log_file, "[%s]%s %s\n", time_str, tag, msg); - fclose(log_file); + FILE* log_file = fopen(kLogPath, "a"); + if (log_file != nullptr) { + fprintf(log_file, "[%s]%s %s\n", time_str, tag, msg); + fclose(log_file); + } } -} } // namespace namespace nxst::log { -void write(Level level, const char* fmt, ...) { - const char* tag = "[INFO] "; - switch (level) { - case Level::Debug: - tag = "[DEBUG]"; - break; - case Level::Info: - tag = "[INFO] "; - break; - case Level::Warn: - tag = "[WARN] "; - break; - case Level::Error: - tag = "[ERROR]"; - break; + void write(Level level, const char* fmt, ...) { + const char* tag = "[INFO] "; + switch (level) { + case Level::Debug: + tag = "[DEBUG]"; + break; + case Level::Info: + tag = "[INFO] "; + break; + case Level::Warn: + tag = "[WARN] "; + break; + case Level::Error: + tag = "[ERROR]"; + break; + } + va_list args; + va_start(args, fmt); + writeEntry(tag, fmt, args); + va_end(args); } - va_list args; - va_start(args, fmt); - writeEntry(tag, fmt, args); - va_end(args); -} -void debug(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - writeEntry("[DEBUG]", fmt, args); - va_end(args); -} -void info(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - writeEntry("[INFO] ", fmt, args); - va_end(args); -} -void warn(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - writeEntry("[WARN] ", fmt, args); - va_end(args); -} -void error(const char* fmt, ...) { - va_list args; - va_start(args, fmt); - writeEntry("[ERROR]", fmt, args); - va_end(args); -} + void debug(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + writeEntry("[DEBUG]", fmt, args); + va_end(args); + } + void info(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + writeEntry("[INFO] ", fmt, args); + va_end(args); + } + void warn(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + writeEntry("[WARN] ", fmt, args); + va_end(args); + } + void error(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + writeEntry("[ERROR]", fmt, args); + va_end(args); + } } // namespace nxst::log diff --git a/src/service/transfer_service.cpp b/src/service/transfer_service.cpp index 6d0b978..440c529 100644 --- a/src/service/transfer_service.cpp +++ b/src/service/transfer_service.cpp @@ -27,514 +27,514 @@ namespace fs = std::filesystem; namespace nxst { -// ─── File-transfer helpers ──────────────────────────────────────────────────── + // ─── File-transfer helpers ──────────────────────────────────────────────────── -static bool sendAll(int sock, const void* buf, size_t len) { - size_t sent = 0; - while (sent < len) { - ssize_t n = send(sock, static_cast<const char*>(buf) + sent, len - sent, 0); - if (n <= 0) - return false; - sent += n; - } - return true; -} - -static bool recvAll(int sock, void* buf, size_t len) { - size_t got = 0; - while (got < len) { - ssize_t n = read(sock, static_cast<char*>(buf) + got, len - got); - if (n <= 0) - return false; - got += n; - } - return true; -} - -static bool sendFile(int sock, const fs::path& filepath, TransferState& state) { - std::ifstream infile(filepath, std::ios::binary | std::ios::ate); - if (!infile.is_open()) - return false; - - uint32_t filename_len = (uint32_t)filepath.string().size(); - uint64_t file_size = (uint64_t)infile.tellg(); - infile.seekg(0, std::ios::beg); - - if (!sendAll(sock, &filename_len, sizeof(filename_len))) - return false; - if (!sendAll(sock, filepath.c_str(), filename_len)) - return false; - if (!sendAll(sock, &file_size, sizeof(file_size))) - return false; - - std::vector<char> buffer(proto::BUF_SIZE); - uint64_t remaining = file_size; - while (remaining > 0) { - size_t to_read = (size_t)std::min(remaining, (uint64_t)proto::BUF_SIZE); - infile.read(buffer.data(), (std::streamsize)to_read); - std::streamsize count = infile.gcount(); - if (count <= 0) - break; - if (!sendAll(sock, buffer.data(), (size_t)count)) - return false; - state.bytes_done.fetch_add((uint64_t)count); - remaining -= (uint64_t)count; - } - return true; -} - -static void mkdirs(const std::string& path) { - for (size_t i = 1; i < path.size(); i++) { - if (path[i] == '/') { - std::string component = path.substr(0, i); - mkdir(component.c_str(), 0777); + static bool sendAll(int sock, const void* buf, size_t len) { + size_t sent = 0; + while (sent < len) { + ssize_t n = send(sock, static_cast<const char*>(buf) + sent, len - sent, 0); + if (n <= 0) + return false; + sent += n; } - } - mkdir(path.c_str(), 0777); -} - -static void receiveFile(int sock, const std::string& rel_path, uint64_t file_size, TransferState& state) { - size_t last_slash = rel_path.rfind('/'); - if (last_slash != std::string::npos) { - std::string dir = rel_path.substr(0, last_slash); - if (!dir.empty()) - mkdirs(dir); + return true; } - FILE* outfile = fopen(rel_path.c_str(), "wb"); - if (!outfile) { - std::vector<char> drain(proto::BUF_SIZE); + static bool recvAll(int sock, void* buf, size_t len) { + size_t got = 0; + while (got < len) { + ssize_t n = read(sock, static_cast<char*>(buf) + got, len - got); + if (n <= 0) + return false; + got += n; + } + return true; + } + + static bool sendFile(int sock, const fs::path& filepath, TransferState& state) { + std::ifstream infile(filepath, std::ios::binary | std::ios::ate); + if (!infile.is_open()) + return false; + + uint32_t filename_len = (uint32_t)filepath.string().size(); + uint64_t file_size = (uint64_t)infile.tellg(); + infile.seekg(0, std::ios::beg); + + if (!sendAll(sock, &filename_len, sizeof(filename_len))) + return false; + if (!sendAll(sock, filepath.c_str(), filename_len)) + return false; + if (!sendAll(sock, &file_size, sizeof(file_size))) + return false; + + std::vector<char> buffer(proto::kBufSize); uint64_t remaining = file_size; while (remaining > 0) { - size_t to_read = (size_t)std::min(remaining, (uint64_t)proto::BUF_SIZE); - ssize_t n = read(sock, drain.data(), to_read); + size_t to_read = (size_t)std::min(remaining, (uint64_t)proto::kBufSize); + infile.read(buffer.data(), (std::streamsize)to_read); + std::streamsize count = infile.gcount(); + if (count <= 0) + break; + if (!sendAll(sock, buffer.data(), (size_t)count)) + return false; + state.bytes_done.fetch_add((uint64_t)count); + remaining -= (uint64_t)count; + } + return true; + } + + static void mkdirs(const std::string& path) { + for (size_t i = 1; i < path.size(); i++) { + if (path[i] == '/') { + std::string component = path.substr(0, i); + mkdir(component.c_str(), 0777); + } + } + mkdir(path.c_str(), 0777); + } + + static void receiveFile(int sock, const std::string& rel_path, uint64_t file_size, TransferState& state) { + size_t last_slash = rel_path.rfind('/'); + if (last_slash != std::string::npos) { + std::string dir = rel_path.substr(0, last_slash); + if (!dir.empty()) + mkdirs(dir); + } + + FILE* outfile = fopen(rel_path.c_str(), "wb"); + if (!outfile) { + std::vector<char> drain(proto::kBufSize); + uint64_t remaining = file_size; + while (remaining > 0) { + size_t to_read = (size_t)std::min(remaining, (uint64_t)proto::kBufSize); + ssize_t n = read(sock, drain.data(), to_read); + if (n <= 0) + break; + remaining -= (uint64_t)n; + } + return; + } + + state.bytes_total.store(file_size); + state.bytes_done.store(0); + + std::vector<char> buffer(proto::kBufSize); + uint64_t total = 0; + while (total < file_size) { + size_t to_read = (size_t)std::min(file_size - total, (uint64_t)proto::kBufSize); + ssize_t n = read(sock, buffer.data(), to_read); if (n <= 0) break; - remaining -= (uint64_t)n; + fwrite(buffer.data(), 1, (size_t)n, outfile); + total += (uint64_t)n; + state.bytes_done.store(total); } - return; + fclose(outfile); } - state.bytes_total.store(file_size); - state.bytes_done.store(0); + // ─── Sender ────────────────────────────────────────────────────────────────── - std::vector<char> buffer(proto::BUF_SIZE); - uint64_t total = 0; - while (total < file_size) { - size_t to_read = (size_t)std::min(file_size - total, (uint64_t)proto::BUF_SIZE); - ssize_t n = read(sock, buffer.data(), to_read); - if (n <= 0) - break; - fwrite(buffer.data(), 1, (size_t)n, outfile); - total += (uint64_t)n; - state.bytes_done.store(total); - } - fclose(outfile); -} - -// ─── Sender ────────────────────────────────────────────────────────────────── - -void TransferService::failSend(const std::string& reason) { - sender_state.fail_reason = reason; - sender_state.connection_failed.store(true); - sender_state.done.store(true); -} - -int TransferService::findServer(char* out_ip) { - int udp_fd = socket(AF_INET, SOCK_DGRAM, 0); - if (udp_fd < 0) - return -1; - sender_udp_sock.store(udp_fd); - - auto releaseUdp = [&]() { - int owned = sender_udp_sock.exchange(-1); - if (owned == udp_fd) - close(udp_fd); - }; - - sockaddr_in addr{}; - addr.sin_family = AF_INET; - addr.sin_port = htons(proto::MULTICAST_PORT); - addr.sin_addr.s_addr = inet_addr(proto::MULTICAST_GROUP); - - if (sendto(udp_fd, "DISCOVER_SERVER", 15, 0, (sockaddr*)&addr, sizeof(addr)) < 0) { - releaseUdp(); - return -1; + void TransferService::failSend(const std::string& reason) { + sender_state.fail_reason = reason; + sender_state.connection_failed.store(true); + sender_state.done.store(true); } - // Poll in 100ms slices so cancel races within 100ms - auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); - while (std::chrono::steady_clock::now() < deadline) { - if (sender_state.cancelled.load()) { + int TransferService::findServer(char* out_ip) { + int udp_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (udp_fd < 0) + return -1; + sender_udp_sock.store(udp_fd); + + auto releaseUdp = [&]() { + int owned = sender_udp_sock.exchange(-1); + if (owned == udp_fd) + close(udp_fd); + }; + + sockaddr_in addr{}; + addr.sin_family = AF_INET; + addr.sin_port = htons(proto::kMulticastPort); + addr.sin_addr.s_addr = inet_addr(proto::kMulticastGroup); + + if (sendto(udp_fd, "DISCOVER_SERVER", 15, 0, (sockaddr*)&addr, sizeof(addr)) < 0) { releaseUdp(); return -1; } - struct timeval tv{0, 100000}; - fd_set fds; - FD_ZERO(&fds); - FD_SET(udp_fd, &fds); - if (select(udp_fd + 1, &fds, nullptr, nullptr, &tv) > 0) { - sockaddr_in from{}; - socklen_t fromlen = sizeof(from); - char buf[256]; - ssize_t n = recvfrom(udp_fd, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen); - if (n > 0) { - buf[n] = '\0'; - if (strcmp(buf, "SERVER_HERE") == 0) { - inet_ntop(AF_INET, &from.sin_addr, out_ip, INET_ADDRSTRLEN); - releaseUdp(); - return 0; + + // Poll in 100ms slices so cancel races within 100ms + auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3); + while (std::chrono::steady_clock::now() < deadline) { + if (sender_state.cancelled.load()) { + releaseUdp(); + return -1; + } + struct timeval tv{0, 100000}; + fd_set fds; + FD_ZERO(&fds); + FD_SET(udp_fd, &fds); + if (select(udp_fd + 1, &fds, nullptr, nullptr, &tv) > 0) { + sockaddr_in from{}; + socklen_t fromlen = sizeof(from); + char buf[256]; + ssize_t n = recvfrom(udp_fd, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen); + if (n > 0) { + buf[n] = '\0'; + if (strcmp(buf, "SERVER_HERE") == 0) { + inet_ntop(AF_INET, &from.sin_addr, out_ip, INET_ADDRSTRLEN); + releaseUdp(); + return 0; + } } } } - } - releaseUdp(); - return -1; -} - -void* TransferService::senderEntry(void* arg) { - auto* a = static_cast<SenderArgs*>(arg); - TransferService* svc = a->svc; - size_t idx = a->title_index; - AccountUid uid = a->uid; - delete a; - svc->runSender(idx, uid); - return nullptr; -} - -void TransferService::runSender(size_t title_index, AccountUid uid) { - sender_active.store(true); - - auto finish = [this]() { - sender_state.done.store(true); - sender_active.store(false); - }; - - char server_ip[INET_ADDRSTRLEN]; - if (findServer(server_ip) != 0) { - if (!sender_state.cancelled.load()) - failSend("No receiver found.\nMake sure the other Switch is in Receive mode."); - return finish(); - } - if (sender_state.cancelled.load()) - return finish(); - - sender_state.setStatus("Creating backup..."); -#ifdef __SWITCH__ - auto backup_result = io::backup(title_index, uid); - if (!backup_result.isOk()) { - failSend("Failed to create backup:\n" + backup_result.error()); - return finish(); - } - fs::path directory = backup_result.value(); -#else - fs::path directory = "."; - (void)title_index; - (void)uid; -#endif - - if (sender_state.cancelled.load()) - return finish(); - - sender_state.setStatus("Connecting..."); - int tcp_fd = socket(AF_INET, SOCK_STREAM, 0); - if (tcp_fd < 0) { - failSend("Failed to open socket."); - return finish(); - } - sender_tcp_sock.store(tcp_fd); - - auto releaseTcp = [&]() { - int owned = sender_tcp_sock.exchange(-1); - if (owned == tcp_fd) - close(tcp_fd); - }; - - sockaddr_in serv{}; - serv.sin_family = AF_INET; - serv.sin_port = htons(proto::TCP_PORT); - if (inet_pton(AF_INET, server_ip, &serv.sin_addr) <= 0 || - connect(tcp_fd, (sockaddr*)&serv, sizeof(serv)) < 0) { - if (!sender_state.cancelled.load()) - failSend("Failed to connect to receiver."); - releaseTcp(); - return finish(); - } - - uint64_t total = 0; - for (const auto& entry : fs::recursive_directory_iterator(directory)) - if (fs::is_regular_file(entry.path())) - total += fs::file_size(entry.path()); - sender_state.bytes_total.store(total); - - for (const auto& entry : fs::recursive_directory_iterator(directory)) { - if (sender_state.cancelled.load()) - break; - const fs::path& p = entry.path(); - if (fs::is_regular_file(p)) { - sender_state.setStatus(p.filename().string()); - if (!sendFile(tcp_fd, p, sender_state)) - break; - } - } - - uint32_t sentinel = proto::EOF_SENTINEL; - sendAll(tcp_fd, &sentinel, sizeof(sentinel)); - - releaseTcp(); - sender_state.setStatus(""); - return finish(); -} - -int TransferService::startSend(size_t title_index, AccountUid uid) { - sender_state.reset(); - sender_state.setStatus("Searching for receiver..."); - - auto* arg = new SenderArgs{this, title_index, uid}; - pthread_t thread; - if (pthread_create(&thread, nullptr, senderEntry, arg) != 0) { - delete arg; + releaseUdp(); return -1; } - pthread_detach(thread); - return 0; -} -void TransferService::cancelSend() { - sender_state.cancelled.store(true); - int udp = sender_udp_sock.exchange(-1); - if (udp >= 0) { - shutdown(udp, SHUT_RDWR); - close(udp); + void* TransferService::senderEntry(void* arg) { + auto* a = static_cast<SenderArgs*>(arg); + TransferService* svc = a->svc; + size_t idx = a->title_index; + AccountUid uid = a->uid; + delete a; + svc->runSender(idx, uid); + return nullptr; } - int tcp = sender_tcp_sock.exchange(-1); - if (tcp >= 0) { - shutdown(tcp, SHUT_RDWR); - close(tcp); - } -} -// ─── Receiver ──────────────────────────────────────────────────────────────── + void TransferService::runSender(size_t title_index, AccountUid uid) { + sender_active.store(true); -std::string TransferService::replaceUsername(const std::string& file_path) const { + auto finish = [this]() { + sender_state.done.store(true); + sender_active.store(false); + }; + + char server_ip[INET_ADDRSTRLEN]; + if (findServer(server_ip) != 0) { + if (!sender_state.cancelled.load()) + failSend("No receiver found.\nMake sure the other Switch is in Receive mode."); + return finish(); + } + if (sender_state.cancelled.load()) + return finish(); + + sender_state.setStatus("Creating backup..."); #ifdef __SWITCH__ - std::string username = - StringUtils::removeNotAscii(StringUtils::removeAccents(Account::username(restore_uid))); - size_t last_slash = file_path.rfind('/'); - if (last_slash == std::string::npos) - return file_path; - size_t prev_slash = file_path.rfind('/', last_slash - 1); - if (prev_slash == std::string::npos) - return username + file_path.substr(last_slash); - return file_path.substr(0, prev_slash + 1) + username + file_path.substr(last_slash); + auto backup_result = io::backup(title_index, uid); + if (!backup_result.isOk()) { + failSend("Failed to create backup:\n" + backup_result.error()); + return finish(); + } + fs::path directory = backup_result.value(); #else - return file_path; + fs::path directory = "."; + (void)title_index; + (void)uid; #endif -} -void* TransferService::broadcastEntry(void* arg) { - static_cast<TransferService*>(arg)->runBroadcast(); - return nullptr; -} + if (sender_state.cancelled.load()) + return finish(); -void TransferService::runBroadcast() { - receiver_broadcast_active.store(true); - pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, nullptr); - pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, nullptr); + sender_state.setStatus("Connecting..."); + int tcp_fd = socket(AF_INET, SOCK_STREAM, 0); + if (tcp_fd < 0) { + failSend("Failed to open socket."); + return finish(); + } + sender_tcp_sock.store(tcp_fd); - int udp = socket(AF_INET, SOCK_DGRAM, 0); - if (udp < 0) { - receiver_broadcast_active.store(false); - return; + auto releaseTcp = [&]() { + int owned = sender_tcp_sock.exchange(-1); + if (owned == tcp_fd) + close(tcp_fd); + }; + + sockaddr_in serv{}; + serv.sin_family = AF_INET; + serv.sin_port = htons(proto::kTcpPort); + if (inet_pton(AF_INET, server_ip, &serv.sin_addr) <= 0 || + connect(tcp_fd, (sockaddr*)&serv, sizeof(serv)) < 0) { + if (!sender_state.cancelled.load()) + failSend("Failed to connect to receiver."); + releaseTcp(); + return finish(); + } + + uint64_t total = 0; + for (const auto& entry : fs::recursive_directory_iterator(directory)) + if (fs::is_regular_file(entry.path())) + total += fs::file_size(entry.path()); + sender_state.bytes_total.store(total); + + for (const auto& entry : fs::recursive_directory_iterator(directory)) { + if (sender_state.cancelled.load()) + break; + const fs::path& p = entry.path(); + if (fs::is_regular_file(p)) { + sender_state.setStatus(p.filename().string()); + if (!sendFile(tcp_fd, p, sender_state)) + break; + } + } + + uint32_t sentinel = proto::kEofSentinel; + sendAll(tcp_fd, &sentinel, sizeof(sentinel)); + + releaseTcp(); + sender_state.setStatus(""); + return finish(); } - receiver_bcast_sock.store(udp); - auto releaseUdp = [&]() { - int owned = receiver_bcast_sock.exchange(-1); - if (owned == udp) + int TransferService::startSend(size_t title_index, AccountUid uid) { + sender_state.reset(); + sender_state.setStatus("Searching for receiver..."); + + auto* arg = new SenderArgs{this, title_index, uid}; + pthread_t thread; + if (pthread_create(&thread, nullptr, senderEntry, arg) != 0) { + delete arg; + return -1; + } + pthread_detach(thread); + return 0; + } + + void TransferService::cancelSend() { + sender_state.cancelled.store(true); + int udp = sender_udp_sock.exchange(-1); + if (udp >= 0) { + shutdown(udp, SHUT_RDWR); close(udp); - }; - - struct timeval tv{0, 20000}; // 20ms poll so cancel/exit wins race with socketExit - setsockopt(udp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); - - sockaddr_in addr{}; - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = htonl(INADDR_ANY); - addr.sin_port = htons(proto::MULTICAST_PORT); - - if (bind(udp, (sockaddr*)&addr, sizeof(addr)) < 0) { - releaseUdp(); - receiver_broadcast_active.store(false); - return; - } - - ip_mreq group{}; - group.imr_multiaddr.s_addr = inet_addr(proto::MULTICAST_GROUP); - group.imr_interface.s_addr = htonl(INADDR_ANY); - if (setsockopt(udp, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group)) < 0) { - releaseUdp(); - receiver_broadcast_active.store(false); - return; - } - - char buf[256]; - sockaddr_in from{}; - socklen_t fromlen = sizeof(from); - while (true) { - ssize_t n = recvfrom(udp, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen); - if (n < 0) { - if (receiver_state.cancelled.load()) - break; - continue; } - buf[n] = '\0'; - if (strcmp(buf, "DISCOVER_SERVER") == 0) { - sendto(udp, "SERVER_HERE", 11, 0, (sockaddr*)&from, fromlen); - break; + int tcp = sender_tcp_sock.exchange(-1); + if (tcp >= 0) { + shutdown(tcp, SHUT_RDWR); + close(tcp); } } - releaseUdp(); - receiver_broadcast_active.store(false); -} + // ─── Receiver ──────────────────────────────────────────────────────────────── -void* TransferService::acceptEntry(void* arg) { - auto* a = static_cast<AcceptArgs*>(arg); - TransferService* svc = a->svc; - int server_fd = a->server_fd; - delete a; - svc->runAccept(server_fd); - return nullptr; -} + std::string TransferService::replaceUsername(const std::string& file_path) const { +#ifdef __SWITCH__ + std::string username = + string_utils::removeNotAscii(string_utils::removeAccents(account::username(restore_uid))); + size_t last_slash = file_path.rfind('/'); + if (last_slash == std::string::npos) + return file_path; + size_t prev_slash = file_path.rfind('/', last_slash - 1); + if (prev_slash == std::string::npos) + return username + file_path.substr(last_slash); + return file_path.substr(0, prev_slash + 1) + username + file_path.substr(last_slash); +#else + return file_path; +#endif + } -void TransferService::runAccept(int server_fd) { - receiver_accept_active.store(true); - receiver_listen_sock.store(server_fd); + void* TransferService::broadcastEntry(void* arg) { + static_cast<TransferService*>(arg)->runBroadcast(); + return nullptr; + } - sockaddr_in client_addr{}; - socklen_t client_len = sizeof(client_addr); - int client_sock = accept(server_fd, (sockaddr*)&client_addr, &client_len); + void TransferService::runBroadcast() { + receiver_broadcast_active.store(true); + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, nullptr); + pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, nullptr); - int owned_listen = receiver_listen_sock.exchange(-1); - if (owned_listen == server_fd) - close(server_fd); + int udp = socket(AF_INET, SOCK_DGRAM, 0); + if (udp < 0) { + receiver_broadcast_active.store(false); + return; + } + receiver_bcast_sock.store(udp); - if (client_sock >= 0) { - receiver_client_sock.store(client_sock); + auto releaseUdp = [&]() { + int owned = receiver_bcast_sock.exchange(-1); + if (owned == udp) + close(udp); + }; + struct timeval tv{0, 20000}; // 20ms poll so cancel/exit wins race with socketExit + setsockopt(udp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + + sockaddr_in addr{}; + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = htonl(INADDR_ANY); + addr.sin_port = htons(proto::kMulticastPort); + + if (bind(udp, (sockaddr*)&addr, sizeof(addr)) < 0) { + releaseUdp(); + receiver_broadcast_active.store(false); + return; + } + + ip_mreq group{}; + group.imr_multiaddr.s_addr = inet_addr(proto::kMulticastGroup); + group.imr_interface.s_addr = htonl(INADDR_ANY); + if (setsockopt(udp, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group)) < 0) { + releaseUdp(); + receiver_broadcast_active.store(false); + return; + } + + char buf[256]; + sockaddr_in from{}; + socklen_t fromlen = sizeof(from); while (true) { - uint32_t filename_len = 0; - if (!recvAll(client_sock, &filename_len, sizeof(filename_len))) - break; - if (filename_len == proto::EOF_SENTINEL) - break; - if (filename_len > proto::MAX_FILENAME) + ssize_t n = recvfrom(udp, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen); + if (n < 0) { + if (receiver_state.cancelled.load()) + break; + continue; + } + buf[n] = '\0'; + if (strcmp(buf, "DISCOVER_SERVER") == 0) { + sendto(udp, "SERVER_HERE", 11, 0, (sockaddr*)&from, fromlen); break; + } + } - std::vector<char> filename_buf(filename_len + 1, '\0'); - if (!recvAll(client_sock, filename_buf.data(), filename_len)) - break; - std::string filename_str(filename_buf.data(), filename_len); - filename_str = replaceUsername(filename_str); + releaseUdp(); + receiver_broadcast_active.store(false); + } - { - size_t sl = filename_str.rfind('/'); - receiver_state.setStatus(sl != std::string::npos ? filename_str.substr(sl + 1) - : filename_str); + void* TransferService::acceptEntry(void* arg) { + auto* a = static_cast<AcceptArgs*>(arg); + TransferService* svc = a->svc; + int server_fd = a->server_fd; + delete a; + svc->runAccept(server_fd); + return nullptr; + } + + void TransferService::runAccept(int server_fd) { + receiver_accept_active.store(true); + receiver_listen_sock.store(server_fd); + + sockaddr_in client_addr{}; + socklen_t client_len = sizeof(client_addr); + int client_sock = accept(server_fd, (sockaddr*)&client_addr, &client_len); + + int owned_listen = receiver_listen_sock.exchange(-1); + if (owned_listen == server_fd) + close(server_fd); + + if (client_sock >= 0) { + receiver_client_sock.store(client_sock); + + while (true) { + uint32_t filename_len = 0; + if (!recvAll(client_sock, &filename_len, sizeof(filename_len))) + break; + if (filename_len == proto::kEofSentinel) + break; + if (filename_len > proto::kMaxFilename) + break; + + std::vector<char> filename_buf(filename_len + 1, '\0'); + if (!recvAll(client_sock, filename_buf.data(), filename_len)) + break; + std::string filename_str(filename_buf.data(), filename_len); + filename_str = replaceUsername(filename_str); + + { + size_t sl = filename_str.rfind('/'); + receiver_state.setStatus(sl != std::string::npos ? filename_str.substr(sl + 1) + : filename_str); + } + + uint64_t file_size = 0; + if (!recvAll(client_sock, &file_size, sizeof(file_size))) + break; + receiveFile(client_sock, filename_str, file_size, receiver_state); } - uint64_t file_size = 0; - if (!recvAll(client_sock, &file_size, sizeof(file_size))) - break; - receiveFile(client_sock, filename_str, file_size, receiver_state); - } + int owned = receiver_client_sock.exchange(-1); + if (owned == client_sock) + close(client_sock); - int owned = receiver_client_sock.exchange(-1); - if (owned == client_sock) - close(client_sock); - - if (!receiver_state.cancelled.load()) { + if (!receiver_state.cancelled.load()) { #ifdef __SWITCH__ - receiver_state.setStatus("Restoring..."); - auto result = io::restore(restore_title_index, restore_uid, 0, restore_title_name); - restore_ok = result.isOk(); - restore_error = result.isOk() ? "" : result.error(); + receiver_state.setStatus("Restoring..."); + auto result = io::restore(restore_title_index, restore_uid, restore_title_name); + restore_ok = result.isOk(); + restore_error = result.isOk() ? "" : result.error(); #else - restore_ok = true; + restore_ok = true; #endif + } } + + receiver_state.done.store(true); + receiver_accept_active.store(false); } - receiver_state.done.store(true); - receiver_accept_active.store(false); -} + int TransferService::startReceive(size_t title_index, AccountUid uid, std::string title_name) { + receiver_state.reset(); + receiver_state.setStatus("Waiting for connection..."); + restore_title_index = title_index; + restore_uid = uid; + restore_title_name = std::move(title_name); + restore_ok = false; + restore_error.clear(); -int TransferService::startReceive(size_t title_index, AccountUid uid, std::string title_name) { - receiver_state.reset(); - receiver_state.setStatus("Waiting for connection..."); - restore_title_index = title_index; - restore_uid = uid; - restore_title_name = std::move(title_name); - restore_ok = false; - restore_error.clear(); + pthread_t bcast_thread; + if (pthread_create(&bcast_thread, nullptr, broadcastEntry, this) != 0) + return 1; + receiver_bcast_thread = bcast_thread; + pthread_detach(bcast_thread); - pthread_t bcast_thread; - if (pthread_create(&bcast_thread, nullptr, broadcastEntry, this) != 0) - return 1; - receiver_bcast_thread = bcast_thread; - pthread_detach(bcast_thread); + Socket server(socket(AF_INET, SOCK_STREAM, 0)); + if (!server.valid()) { + cancelReceive(); + return 1; + } - Socket server(socket(AF_INET, SOCK_STREAM, 0)); - if (!server.valid()) { - cancelReceive(); - return 1; + int yes = 1; + setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)); + + sockaddr_in addr{}; + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = INADDR_ANY; + addr.sin_port = htons(proto::kTcpPort); + + if (bind(server, (sockaddr*)&addr, sizeof(addr)) < 0 || listen(server, 3) < 0) { + cancelReceive(); + return 1; + } + + auto* acc_args = new AcceptArgs{this, server.fd}; + pthread_t accept_thread; + if (pthread_create(&accept_thread, nullptr, acceptEntry, acc_args) != 0) { + delete acc_args; + cancelReceive(); + return 1; + } + pthread_detach(accept_thread); + server.release(); + return 0; } - int yes = 1; - setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)); - - sockaddr_in addr{}; - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = INADDR_ANY; - addr.sin_port = htons(proto::TCP_PORT); - - if (bind(server, (sockaddr*)&addr, sizeof(addr)) < 0 || listen(server, 3) < 0) { - cancelReceive(); - return 1; + void TransferService::cancelReceive() { + receiver_state.cancelled.store(true); + int sock = receiver_client_sock.exchange(-1); + if (sock >= 0) { + shutdown(sock, SHUT_RDWR); + close(sock); + } + int lsock = receiver_listen_sock.exchange(-1); + if (lsock >= 0) { + shutdown(lsock, SHUT_RDWR); + close(lsock); + } + int bsock = receiver_bcast_sock.exchange(-1); + if (bsock >= 0) { + shutdown(bsock, SHUT_RDWR); + close(bsock); + } + if (receiver_broadcast_active.load()) + pthread_cancel(receiver_bcast_thread); } - auto* acc_args = new AcceptArgs{this, server.fd}; - pthread_t accept_thread; - if (pthread_create(&accept_thread, nullptr, acceptEntry, acc_args) != 0) { - delete acc_args; - cancelReceive(); - return 1; - } - pthread_detach(accept_thread); - server.release(); - return 0; -} - -void TransferService::cancelReceive() { - receiver_state.cancelled.store(true); - int sock = receiver_client_sock.exchange(-1); - if (sock >= 0) { - shutdown(sock, SHUT_RDWR); - close(sock); - } - int lsock = receiver_listen_sock.exchange(-1); - if (lsock >= 0) { - shutdown(lsock, SHUT_RDWR); - close(lsock); - } - int bsock = receiver_bcast_sock.exchange(-1); - if (bsock >= 0) { - shutdown(bsock, SHUT_RDWR); - close(bsock); - } - if (receiver_broadcast_active.load()) - pthread_cancel(receiver_bcast_thread); -} - } // namespace nxst diff --git a/src/ui/titles_layout.cpp b/src/ui/titles_layout.cpp index 4df3ead..6b8c11f 100644 --- a/src/ui/titles_layout.cpp +++ b/src/ui/titles_layout.cpp @@ -1,312 +1,312 @@ #include <nxst/app/main_application.hpp> #include <nxst/domain/util.hpp> -#include <nxst/ui/const.h> #include <nxst/ui/transfer_overlay.hpp> namespace ui { -extern MainApplication* mainApp; + extern MainApplication* mainApp; -namespace { -constexpr int ListX = theme::space::lg; -constexpr int ListW = 760; -constexpr int PanelX = ListX + ListW + theme::space::xl; -constexpr int PanelW = theme::layout::ScreenW - PanelX - theme::space::lg; -constexpr int ContentY = theme::layout::ContentTop + theme::space::md; -constexpr int ContentH = theme::layout::ContentH - 2 * theme::space::md; -constexpr int BtnH = 56; -constexpr int BtnW = PanelW - 2 * theme::space::lg; -} // namespace + namespace { + constexpr int ListX = theme::space::lg; + constexpr int ListW = 760; + constexpr int PanelX = ListX + ListW + theme::space::xl; + constexpr int PanelW = theme::layout::ScreenW - PanelX - theme::space::lg; + constexpr int ContentY = theme::layout::ContentTop + theme::space::md; + constexpr int ContentH = theme::layout::ContentH - 2 * theme::space::md; + constexpr int BtnH = 56; + constexpr int BtnW = PanelW - 2 * theme::space::lg; + } // namespace -TitlesLayout::TitlesLayout() : Layout::Layout() { - using namespace theme; + TitlesLayout::TitlesLayout() { + using namespace theme; - this->titlesMenu = - pu::ui::elm::Menu::New(ListX, ContentY, ListW, color::BgBase, color::BgSurface2, 88, 6); - this->titlesMenu->SetScrollbarColor(color::Primary); - this->titlesMenu->SetItemsFocusColor(color::BgSurface2); - this->titlesMenu->SetOnSelectionChanged([this]() { - this->refreshPanel(); - }); - this->SetBackgroundColor(color::BgBase); - this->Add(this->titlesMenu); + this->titlesMenu = + pu::ui::elm::Menu::New(ListX, ContentY, ListW, color::BgBase, color::BgSurface2, 88, 6); + this->titlesMenu->SetScrollbarColor(color::Primary); + this->titlesMenu->SetItemsFocusColor(color::BgSurface2); + this->titlesMenu->SetOnSelectionChanged([this]() { + this->refreshPanel(); + }); + this->SetBackgroundColor(color::BgBase); + this->Add(this->titlesMenu); - this->panelBg = - pu::ui::elm::Rectangle::New(PanelX, ContentY, PanelW, ContentH, color::BgSurface, radius::lg); - this->Add(this->panelBg); + this->panelBg = + pu::ui::elm::Rectangle::New(PanelX, ContentY, PanelW, ContentH, color::BgSurface, radius::lg); + this->Add(this->panelBg); - this->panelTitle = pu::ui::elm::TextBlock::New(PanelX + space::lg, ContentY + space::lg, ""); - this->panelTitle->SetFont(type::font(type::Title)); - this->panelTitle->SetColor(color::TextPrimary); - this->Add(this->panelTitle); + this->panelTitle = pu::ui::elm::TextBlock::New(PanelX + space::lg, ContentY + space::lg, ""); + this->panelTitle->SetFont(type::font(type::Title)); + this->panelTitle->SetColor(color::TextPrimary); + this->Add(this->panelTitle); - this->panelHint = - pu::ui::elm::TextBlock::New(PanelX + space::lg, ContentY + space::lg + 48, "Pick an action:"); - this->panelHint->SetFont(type::font(type::Body)); - this->panelHint->SetColor(color::TextSecondary); - this->Add(this->panelHint); + this->panelHint = + pu::ui::elm::TextBlock::New(PanelX + space::lg, ContentY + space::lg + 48, "Pick an action:"); + this->panelHint->SetFont(type::font(type::Body)); + this->panelHint->SetColor(color::TextSecondary); + this->Add(this->panelHint); - int btnY = ContentY + 200; - this->btnTransferBg = - pu::ui::elm::Rectangle::New(PanelX + space::lg, btnY, BtnW, BtnH, color::BgSurface2, radius::md); - this->Add(this->btnTransferBg); - this->btnTransferText = - pu::ui::elm::TextBlock::New(PanelX + space::lg + space::md, btnY + 14, "Transfer to another device"); - this->btnTransferText->SetFont(type::font(type::Body)); - this->btnTransferText->SetColor(color::TextSecondary); - this->Add(this->btnTransferText); + int btnY = ContentY + 200; + this->btnTransferBg = + pu::ui::elm::Rectangle::New(PanelX + space::lg, btnY, BtnW, BtnH, color::BgSurface2, radius::md); + this->Add(this->btnTransferBg); + this->btnTransferText = pu::ui::elm::TextBlock::New(PanelX + space::lg + space::md, btnY + 14, + "Transfer to another device"); + this->btnTransferText->SetFont(type::font(type::Body)); + this->btnTransferText->SetColor(color::TextSecondary); + this->Add(this->btnTransferText); - int btnY2 = btnY + BtnH + space::md; - this->btnReceiveBg = - pu::ui::elm::Rectangle::New(PanelX + space::lg, btnY2, BtnW, BtnH, color::BgSurface2, radius::md); - this->Add(this->btnReceiveBg); - this->btnReceiveText = pu::ui::elm::TextBlock::New(PanelX + space::lg + space::md, btnY2 + 14, - "Receive from another device"); - this->btnReceiveText->SetFont(type::font(type::Body)); - this->btnReceiveText->SetColor(color::TextSecondary); - this->Add(this->btnReceiveText); + int btnY2 = btnY + BtnH + space::md; + this->btnReceiveBg = + pu::ui::elm::Rectangle::New(PanelX + space::lg, btnY2, BtnW, BtnH, color::BgSurface2, radius::md); + this->Add(this->btnReceiveBg); + this->btnReceiveText = pu::ui::elm::TextBlock::New(PanelX + space::lg + space::md, btnY2 + 14, + "Receive from another device"); + this->btnReceiveText->SetFont(type::font(type::Body)); + this->btnReceiveText->SetColor(color::TextSecondary); + this->Add(this->btnReceiveText); - this->panelFooter = pu::ui::elm::TextBlock::New(PanelX + space::lg, ContentY + ContentH - space::lg - 18, - "Save data only"); - this->panelFooter->SetFont(type::font(type::Caption)); - this->panelFooter->SetColor(color::TextMuted); - this->Add(this->panelFooter); + this->panelFooter = pu::ui::elm::TextBlock::New( + PanelX + space::lg, ContentY + ContentH - space::lg - 18, "Save data only"); + this->panelFooter->SetFont(type::font(type::Caption)); + this->panelFooter->SetColor(color::TextMuted); + this->Add(this->panelFooter); - this->emptyText = pu::ui::elm::TextBlock::New(ListX + ListW / 2 - 280, ContentY + ContentH / 2 - 40, - "No save data on this profile"); - this->emptyText->SetFont(type::font(type::Display)); - this->emptyText->SetColor(color::TextPrimary); - this->emptyText->SetVisible(false); - this->Add(this->emptyText); + this->emptyText = pu::ui::elm::TextBlock::New(ListX + ListW / 2 - 280, ContentY + ContentH / 2 - 40, + "No save data on this profile"); + this->emptyText->SetFont(type::font(type::Display)); + this->emptyText->SetColor(color::TextPrimary); + this->emptyText->SetVisible(false); + this->Add(this->emptyText); - this->emptySub = pu::ui::elm::TextBlock::New(ListX + ListW / 2 - 220, ContentY + ContentH / 2 + 16, - "Play something first, then come back."); - this->emptySub->SetFont(type::font(type::Body)); - this->emptySub->SetColor(color::TextMuted); - this->emptySub->SetVisible(false); - this->Add(this->emptySub); + this->emptySub = pu::ui::elm::TextBlock::New(ListX + ListW / 2 - 220, ContentY + ContentH / 2 + 16, + "Play something first, then come back."); + this->emptySub->SetFont(type::font(type::Body)); + this->emptySub->SetColor(color::TextMuted); + this->emptySub->SetVisible(false); + this->Add(this->emptySub); - this->header = std::make_unique<HeaderBar>(this, "Save Transfer"); - this->hints = std::make_unique<HintBar>(this); - this->updateHints(); -} + this->header = std::make_unique<HeaderBar>(this, "Save Transfer"); + this->hints = std::make_unique<HintBar>(this); + this->updateHints(); + } -void TitlesLayout::InitTitles(AccountUid uid) { - using namespace theme; - this->current_uid = uid; + void TitlesLayout::InitTitles(AccountUid uid) { + using namespace theme; + this->current_uid = uid; - auto it = this->menuCache.find(uid); - std::vector<pu::ui::elm::MenuItem::Ref>* items; - if (it != this->menuCache.end()) { - items = &it->second; - } else { - std::vector<pu::ui::elm::MenuItem::Ref> built; - for (size_t i = 0; i < getTitleCount(uid); i++) { - Title title; - getTitle(title, uid, i); - auto titleItem = pu::ui::elm::MenuItem::New(title.name().c_str()); - titleItem->SetColor(color::TextPrimary); - built.push_back(titleItem); + auto it = this->menuCache.find(uid); + std::vector<pu::ui::elm::MenuItem::Ref>* items; + if (it != this->menuCache.end()) { + items = &it->second; + } else { + std::vector<pu::ui::elm::MenuItem::Ref> built; + for (size_t i = 0; i < getTitleCount(uid); i++) { + Title title; + getTitle(title, uid, i); + auto titleItem = pu::ui::elm::MenuItem::New(title.name().c_str()); + titleItem->SetColor(color::TextPrimary); + built.push_back(titleItem); + } + auto inserted = this->menuCache.emplace(uid, std::move(built)); + items = &inserted.first->second; } - auto inserted = this->menuCache.emplace(uid, std::move(built)); - items = &inserted.first->second; + + this->titlesMenu->ClearItems(); + for (auto& item : *items) { + this->titlesMenu->AddItem(item); + } + this->titlesMenu->SetSelectedIndex(0); + + const bool empty = items->empty(); + this->titlesMenu->SetVisible(!empty); + this->panelBg->SetVisible(!empty); + this->panelTitle->SetVisible(!empty); + this->panelHint->SetVisible(!empty); + this->btnTransferBg->SetVisible(!empty); + this->btnTransferText->SetVisible(!empty); + this->btnReceiveBg->SetVisible(!empty); + this->btnReceiveText->SetVisible(!empty); + this->panelFooter->SetVisible(!empty); + this->emptyText->SetVisible(empty); + this->emptySub->SetVisible(empty); + + this->focus = TitlesFocus::List; + this->action = TitlesAction::Transfer; + this->refreshPanel(); + this->refreshButtons(); + this->updateHints(); + + this->header->SetUser(uid, account::username(uid)); } - this->titlesMenu->ClearItems(); - for (auto& item : *items) { - this->titlesMenu->AddItem(item); + void TitlesLayout::refreshPanel() { + if (this->titlesMenu->GetItems().empty()) + return; + int idx = this->titlesMenu->GetSelectedIndex(); + Title title; + getTitle(title, this->current_uid, idx); + this->panelTitle->SetText(string_utils::elide(title.name(), 24)); } - this->titlesMenu->SetSelectedIndex(0); - const bool empty = items->empty(); - this->titlesMenu->SetVisible(!empty); - this->panelBg->SetVisible(!empty); - this->panelTitle->SetVisible(!empty); - this->panelHint->SetVisible(!empty); - this->btnTransferBg->SetVisible(!empty); - this->btnTransferText->SetVisible(!empty); - this->btnReceiveBg->SetVisible(!empty); - this->btnReceiveText->SetVisible(!empty); - this->panelFooter->SetVisible(!empty); - this->emptyText->SetVisible(empty); - this->emptySub->SetVisible(empty); - - this->focus = TitlesFocus::List; - this->action = TitlesAction::Transfer; - this->refreshPanel(); - this->refreshButtons(); - this->updateHints(); - - this->header->SetUser(uid, Account::username(uid)); -} - -void TitlesLayout::refreshPanel() { - if (this->titlesMenu->GetItems().empty()) - return; - int idx = this->titlesMenu->GetSelectedIndex(); - Title title; - getTitle(title, this->current_uid, idx); - this->panelTitle->SetText(StringUtils::elide(title.name(), 24)); -} - -void TitlesLayout::refreshButtons() { - using namespace theme; - const bool active = (focus == TitlesFocus::Actions); - if (active && action == TitlesAction::Transfer) { - this->btnTransferBg->SetColor(color::Primary); - this->btnTransferText->SetColor(color::TextPrimary); - this->btnReceiveBg->SetColor(color::BgSurface2); - this->btnReceiveText->SetColor(color::TextSecondary); - } else if (active && action == TitlesAction::Receive) { - this->btnTransferBg->SetColor(color::BgSurface2); - this->btnTransferText->SetColor(color::TextSecondary); - this->btnReceiveBg->SetColor(color::Accent); - this->btnReceiveText->SetColor(color::BgBase); - } else { - this->btnTransferBg->SetColor(color::BgSurface2); - this->btnTransferText->SetColor(color::TextSecondary); - this->btnReceiveBg->SetColor(color::BgSurface2); - this->btnReceiveText->SetColor(color::TextSecondary); + void TitlesLayout::refreshButtons() { + using namespace theme; + const bool active = (focus == TitlesFocus::Actions); + if (active && action == TitlesAction::Transfer) { + this->btnTransferBg->SetColor(color::Primary); + this->btnTransferText->SetColor(color::TextPrimary); + this->btnReceiveBg->SetColor(color::BgSurface2); + this->btnReceiveText->SetColor(color::TextSecondary); + } else if (active && action == TitlesAction::Receive) { + this->btnTransferBg->SetColor(color::BgSurface2); + this->btnTransferText->SetColor(color::TextSecondary); + this->btnReceiveBg->SetColor(color::Accent); + this->btnReceiveText->SetColor(color::BgBase); + } else { + this->btnTransferBg->SetColor(color::BgSurface2); + this->btnTransferText->SetColor(color::TextSecondary); + this->btnReceiveBg->SetColor(color::BgSurface2); + this->btnReceiveText->SetColor(color::TextSecondary); + } } -} -void TitlesLayout::updateHints() { - if (focus == TitlesFocus::List) { - this->hints->SetHints({{"A", "Choose action"}, {"B", "Back"}, {"+", "Quit"}}); - } else { - this->hints->SetHints({{"A", "Confirm"}, {"B", "Back"}}); + void TitlesLayout::updateHints() { + if (focus == TitlesFocus::List) { + this->hints->SetHints({{"A", "Choose action"}, {"B", "Back"}, {"+", "Quit"}}); + } else { + this->hints->SetHints({{"A", "Confirm"}, {"B", "Back"}}); + } } -} -void TitlesLayout::runTransfer(int index, Title& title) { - (void)title; - auto ovl = TransferOverlay::New("Transferring save data..."); - this->titlesMenu->SetVisible(false); - mainApp->StartOverlay(ovl); - this->LockInput(); - if (mainApp->transfer.startSend((size_t)index, this->current_uid) != 0) { + void TitlesLayout::runTransfer(int index, Title& title) { + (void)title; + auto ovl = TransferOverlay::New("Transferring save data..."); + this->titlesMenu->SetVisible(false); + mainApp->StartOverlay(ovl); + this->LockInput(); + if (mainApp->transfer.startSend((size_t)index, this->current_uid) != 0) { + mainApp->EndOverlay(); + this->titlesMenu->SetVisible(true); + this->UnlockInput(); + mainApp->CreateShowDialog("Transfer", "Failed to start transfer.", {"OK"}, true); + return; + } + while (!mainApp->transfer.isSendDone()) { + ovl->SetStatus(mainApp->transfer.sendStatusText()); + ovl->SetProgressVisible(mainApp->transfer.isSendProgressKnown()); + ovl->SetProgress(mainApp->transfer.sendProgress()); + mainApp->CallForRender(); + if (mainApp->GetButtonsDown() & HidNpadButton_B) { + mainApp->transfer.cancelSend(); + } + svcSleepThread(16666666LL); + } mainApp->EndOverlay(); this->titlesMenu->SetVisible(true); this->UnlockInput(); - mainApp->CreateShowDialog("Transfer", "Failed to start transfer.", {"OK"}, true); - return; + + if (mainApp->transfer.isSendConnectionFailed()) { + mainApp->CreateShowDialog("Transfer", mainApp->transfer.sendFailReason(), {"OK"}, true); + } else if (mainApp->transfer.isSendCancelled()) { + mainApp->CreateShowDialog("Transfer", "Transfer cancelled.", {"OK"}, true); + } else { + mainApp->CreateShowDialog("Transfer", "Save data sent successfully!", {"OK"}, true); + } } - while (!mainApp->transfer.isSendDone()) { - ovl->SetStatus(mainApp->transfer.sendStatusText()); - ovl->SetProgressVisible(mainApp->transfer.isSendProgressKnown()); - ovl->SetProgress(mainApp->transfer.sendProgress()); - mainApp->CallForRender(); - if (mainApp->GetButtonsDown() & HidNpadButton_B) { + + void TitlesLayout::runReceive(int index, Title& title) { + if (mainApp->transfer.startReceive((size_t)index, this->current_uid, title.name()) != 0) { + mainApp->CreateShowDialog("Receive", "Failed to start receiver.\nCheck network connection.", + {"OK"}, true); + return; + } + auto ovl = TransferOverlay::New("Receiving save data..."); + this->titlesMenu->SetVisible(false); + mainApp->StartOverlay(ovl); + this->LockInput(); + while (!mainApp->transfer.isReceiveDone()) { + ovl->SetStatus(mainApp->transfer.receiveStatusText()); + ovl->SetProgress(mainApp->transfer.receiveProgress()); + mainApp->CallForRender(); + if (mainApp->GetButtonsDown() & HidNpadButton_B) { + mainApp->transfer.cancelReceive(); + } + svcSleepThread(16666666LL); + } + mainApp->EndOverlay(); + this->titlesMenu->SetVisible(true); + this->UnlockInput(); + + if (mainApp->transfer.isReceiveCancelled()) { + mainApp->CreateShowDialog("Receive", "Transfer cancelled.", {"OK"}, true); + } else if (mainApp->transfer.restoreSucceeded()) { + mainApp->CreateShowDialog("Receive", "Save data received and restored successfully!", {"OK"}, + true); + } else { + mainApp->CreateShowDialog("Receive", "Restore failed:\n" + mainApp->transfer.restoreError(), + {"OK"}, true); + } + } + + void TitlesLayout::onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos) { + (void)Up; + (void)Held; + (void)Pos; + if (m_inputLocked) + return; + + if (Down & HidNpadButton_Plus) { mainApp->transfer.cancelSend(); - } - svcSleepThread(16666666LL); - } - mainApp->EndOverlay(); - this->titlesMenu->SetVisible(true); - this->UnlockInput(); - - if (mainApp->transfer.isSendConnectionFailed()) { - mainApp->CreateShowDialog("Transfer", mainApp->transfer.sendFailReason(), {"OK"}, true); - } else if (mainApp->transfer.isSendCancelled()) { - mainApp->CreateShowDialog("Transfer", "Transfer cancelled.", {"OK"}, true); - } else { - mainApp->CreateShowDialog("Transfer", "Save data sent successfully!", {"OK"}, true); - } -} - -void TitlesLayout::runReceive(int index, Title& title) { - if (mainApp->transfer.startReceive((size_t)index, this->current_uid, title.name()) != 0) { - mainApp->CreateShowDialog("Receive", "Failed to start receiver.\nCheck network connection.", {"OK"}, - true); - return; - } - auto ovl = TransferOverlay::New("Receiving save data..."); - this->titlesMenu->SetVisible(false); - mainApp->StartOverlay(ovl); - this->LockInput(); - while (!mainApp->transfer.isReceiveDone()) { - ovl->SetStatus(mainApp->transfer.receiveStatusText()); - ovl->SetProgress(mainApp->transfer.receiveProgress()); - mainApp->CallForRender(); - if (mainApp->GetButtonsDown() & HidNpadButton_B) { mainApp->transfer.cancelReceive(); - } - svcSleepThread(16666666LL); - } - mainApp->EndOverlay(); - this->titlesMenu->SetVisible(true); - this->UnlockInput(); - - if (mainApp->transfer.isReceiveCancelled()) { - mainApp->CreateShowDialog("Receive", "Transfer cancelled.", {"OK"}, true); - } else if (mainApp->transfer.restoreSucceeded()) { - mainApp->CreateShowDialog("Receive", "Save data received and restored successfully!", {"OK"}, true); - } else { - mainApp->CreateShowDialog("Receive", "Restore failed:\n" + mainApp->transfer.restoreError(), {"OK"}, - true); - } -} - -void TitlesLayout::onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos) { - (void)Up; - (void)Held; - (void)Pos; - if (m_inputLocked) - return; - - if (Down & HidNpadButton_Plus) { - mainApp->transfer.cancelSend(); - mainApp->transfer.cancelReceive(); - mainApp->Close(); - return; - } - - if (focus == TitlesFocus::List) { - if (Down & HidNpadButton_B) { - this->header->SetUser(std::nullopt, ""); - mainApp->LoadLayout(mainApp->users_layout); + mainApp->Close(); return; } - if (Down & HidNpadButton_A) { - if (this->titlesMenu->GetItems().empty()) + + if (focus == TitlesFocus::List) { + if (Down & HidNpadButton_B) { + this->header->SetUser(std::nullopt, ""); + mainApp->LoadLayout(mainApp->users_layout); return; - this->lockedListIndex = this->titlesMenu->GetSelectedIndex(); - this->focus = TitlesFocus::Actions; - this->action = TitlesAction::Transfer; - this->refreshButtons(); - this->updateHints(); - return; - } - } else { - if (this->titlesMenu->GetSelectedIndex() != this->lockedListIndex) { - this->titlesMenu->SetSelectedIndex(this->lockedListIndex); - } - if (Down & HidNpadButton_B) { - this->focus = TitlesFocus::List; - this->refreshButtons(); - this->updateHints(); - return; - } - if (Down & - (HidNpadButton_Up | HidNpadButton_Down | HidNpadButton_StickLUp | HidNpadButton_StickLDown)) { - this->action = - (action == TitlesAction::Transfer) ? TitlesAction::Receive : TitlesAction::Transfer; - this->refreshButtons(); - return; - } - if (Down & HidNpadButton_A) { - int idx = this->titlesMenu->GetSelectedIndex(); - Title title; - getTitle(title, this->current_uid, idx); - TitlesAction chosen = action; - this->focus = TitlesFocus::List; - this->refreshButtons(); - this->updateHints(); - if (chosen == TitlesAction::Transfer) { - this->runTransfer(idx, title); - } else { - this->runReceive(idx, title); + } + if (Down & HidNpadButton_A) { + if (this->titlesMenu->GetItems().empty()) + return; + this->lockedListIndex = this->titlesMenu->GetSelectedIndex(); + this->focus = TitlesFocus::Actions; + this->action = TitlesAction::Transfer; + this->refreshButtons(); + this->updateHints(); + return; + } + } else { + if (this->titlesMenu->GetSelectedIndex() != this->lockedListIndex) { + this->titlesMenu->SetSelectedIndex(this->lockedListIndex); + } + if (Down & HidNpadButton_B) { + this->focus = TitlesFocus::List; + this->refreshButtons(); + this->updateHints(); + return; + } + if (Down & + (HidNpadButton_Up | HidNpadButton_Down | HidNpadButton_StickLUp | HidNpadButton_StickLDown)) { + this->action = + (action == TitlesAction::Transfer) ? TitlesAction::Receive : TitlesAction::Transfer; + this->refreshButtons(); + return; + } + if (Down & HidNpadButton_A) { + int idx = this->titlesMenu->GetSelectedIndex(); + Title title; + getTitle(title, this->current_uid, idx); + TitlesAction chosen = action; + this->focus = TitlesFocus::List; + this->refreshButtons(); + this->updateHints(); + if (chosen == TitlesAction::Transfer) { + this->runTransfer(idx, title); + } else { + this->runReceive(idx, title); + } } } } -} } // namespace ui diff --git a/src/ui/users_layout.cpp b/src/ui/users_layout.cpp index 3991655..22a315e 100644 --- a/src/ui/users_layout.cpp +++ b/src/ui/users_layout.cpp @@ -1,69 +1,69 @@ #include <nxst/app/main_application.hpp> namespace ui { -extern MainApplication* mainApp; + extern MainApplication* mainApp; -UsersLayout::UsersLayout() : Layout::Layout() { - using namespace theme; + UsersLayout::UsersLayout() : Layout::Layout() { + using namespace theme; - this->usersMenu = pu::ui::elm::Menu::New(0, layout::ContentTop + space::md, layout::ScreenW, - color::BgBase, color::BgSurface2, 88, 6); - this->usersMenu->SetScrollbarColor(color::Primary); - this->usersMenu->SetItemsFocusColor(color::BgSurface2); + this->usersMenu = pu::ui::elm::Menu::New(0, layout::ContentTop + space::md, layout::ScreenW, + color::BgBase, color::BgSurface2, 88, 6); + this->usersMenu->SetScrollbarColor(color::Primary); + this->usersMenu->SetItemsFocusColor(color::BgSurface2); - for (AccountUid const& uid : Account::ids()) { - auto item = pu::ui::elm::MenuItem::New(Account::username(uid)); - item->SetColor(color::TextPrimary); - this->usersMenu->AddItem(item); - } - - this->loadingBg = pu::ui::elm::Rectangle::New(0, 0, layout::ScreenW, layout::ScreenH, color::Scrim); - this->loadingBg->SetVisible(false); - - this->loadingText = - pu::ui::elm::TextBlock::New(layout::ScreenW / 2 - 120, layout::ScreenH / 2 - 12, "Loading saves..."); - this->loadingText->SetFont(type::font(type::Body)); - this->loadingText->SetColor(color::TextSecondary); - this->loadingText->SetVisible(false); - - this->SetBackgroundColor(color::BgBase); - this->Add(this->usersMenu); - this->Add(this->loadingBg); - this->Add(this->loadingText); - - this->header = std::make_unique<HeaderBar>(this, "Select a user"); - this->hints = std::make_unique<HintBar>(this); - this->hints->SetHints({{"A", "Select"}, {"+", "Quit"}}); -} - -int32_t UsersLayout::GetCurrentIndex() { - return this->usersMenu->GetSelectedIndex(); -} - -void UsersLayout::onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos) { - if (Down & HidNpadButton_Plus) { - mainApp->Close(); - return; - } - - if (Down & HidNpadButton_A) { - AccountUid uid = Account::ids().at(this->usersMenu->GetSelectedIndex()); - - if (!areTitlesLoaded()) { - this->usersMenu->SetVisible(false); - this->loadingBg->SetVisible(true); - this->loadingText->SetVisible(true); - mainApp->CallForRender(); - - loadTitles(); - - this->loadingBg->SetVisible(false); - this->loadingText->SetVisible(false); - this->usersMenu->SetVisible(true); + for (AccountUid const& uid : account::ids()) { + auto item = pu::ui::elm::MenuItem::New(account::username(uid)); + item->SetColor(color::TextPrimary); + this->usersMenu->AddItem(item); } - mainApp->titles_layout->InitTitles(uid); - mainApp->LoadLayout(mainApp->titles_layout); + this->loadingBg = pu::ui::elm::Rectangle::New(0, 0, layout::ScreenW, layout::ScreenH, color::Scrim); + this->loadingBg->SetVisible(false); + + this->loadingText = pu::ui::elm::TextBlock::New(layout::ScreenW / 2 - 120, layout::ScreenH / 2 - 12, + "Loading saves..."); + this->loadingText->SetFont(type::font(type::Body)); + this->loadingText->SetColor(color::TextSecondary); + this->loadingText->SetVisible(false); + + this->SetBackgroundColor(color::BgBase); + this->Add(this->usersMenu); + this->Add(this->loadingBg); + this->Add(this->loadingText); + + this->header = std::make_unique<HeaderBar>(this, "Select a user"); + this->hints = std::make_unique<HintBar>(this); + this->hints->SetHints({{"A", "Select"}, {"+", "Quit"}}); + } + + int32_t UsersLayout::GetCurrentIndex() { + return this->usersMenu->GetSelectedIndex(); + } + + void UsersLayout::onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos) { + if (Down & HidNpadButton_Plus) { + mainApp->Close(); + return; + } + + if (Down & HidNpadButton_A) { + AccountUid uid = account::ids().at(this->usersMenu->GetSelectedIndex()); + + if (!areTitlesLoaded()) { + this->usersMenu->SetVisible(false); + this->loadingBg->SetVisible(true); + this->loadingText->SetVisible(true); + mainApp->CallForRender(); + + loadTitles(); + + this->loadingBg->SetVisible(false); + this->loadingText->SetVisible(false); + this->usersMenu->SetVisible(true); + } + + mainApp->titles_layout->InitTitles(uid); + mainApp->LoadLayout(mainApp->titles_layout); + } } -} } // namespace ui