another stage of refactoring

- AccountProfileHandle RAII wrapper in handles.hpp; applied in
  account.cpp (getUser, iconPath) replacing manual accountProfileClose
- FILE* in iconPath replaced with existing FileHandle RAII wrapper
- io::restore split into clearSaveRoot + extractAndCommit static helpers;
  public signature unchanged
- sendAll/recvAll kept as bool — callers don't propagate the error string,
  Result<void> would add noise without benefit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.clang-format

@@ -26,3 +26,4 @@ IncludeCategories:
 SpacesBeforeTrailingComments: 2
 Cpp11BracedListStyle: true
 Standard: c++17
+NamespaceIndentation: All

.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .serena
+.idea/
 
 # Prerequisites
 *.d

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)

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/<title>/<user>/...`).
 - On the receiver, the username path component is rewritten to match the local user's nickname before writing to disk.
 

include/nxst/app/main.hpp

@@ -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...";

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

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 {
@@ -62,11 +28,9 @@ struct User {
 };
 
 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);
+    Result init();
+    void exit();
+    std::vector<AccountUid> ids();
+    std::string username(AccountUid id);
+    std::string iconPath(AccountUid id);
 }  // namespace Account

include/nxst/domain/common.hpp

@@ -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);

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

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

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();

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);
+    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 StringUtils

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};
 };

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);
+    Result mount(FsFileSystem* fs, u64 title_id, AccountUid uid);
+    int mount(FsFileSystem fs);
+    void unmount();
 }  // namespace FileSystem

include/nxst/infra/fs/handles.hpp

@@ -5,48 +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};
+
+        AccountProfileHandle() = default;
+        ~AccountProfileHandle() {
+            if (valid)
+                accountProfileClose(&profile);
+        }  // NOLINT(modernize-use-equals-default)
+
+        AccountProfileHandle(const AccountProfileHandle&) = delete;
+        AccountProfileHandle& operator=(const AccountProfileHandle&) = delete;
+
+        AccountProfile* get() {
+            return &profile;
+        }
+    };
 
 }  // namespace nxst

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

include/nxst/infra/net/transfer_receiver.hpp

@@ -1 +0,0 @@
-#pragma once

include/nxst/infra/net/transfer_sender.hpp

@@ -1 +0,0 @@
-#pragma once

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

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

include/nxst/ui/card.hpp

@@ -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

include/nxst/ui/const.h

@@ -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

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

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

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

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

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(StringUtils::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

include/nxst/ui/ui_context.hpp

@@ -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

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

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;

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

src/domain/account.cpp

@@ -1,37 +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;
@@ -39,48 +18,47 @@ 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, ""};
-    AccountProfile profile;
-    AccountProfileBase profilebase;
-    memset(&profilebase, 0, sizeof(profilebase));
+    nxst::AccountProfileHandle profile;
+    AccountProfileBase base{};
 
-    if (R_SUCCEEDED(accountGetProfile(&profile, id))) {
-        if (R_SUCCEEDED(accountProfileGet(&profile, NULL, &profilebase))) {
-            user.name = std::string(profilebase.nickname);
+    if (R_SUCCEEDED(accountGetProfile(profile.get(), id))) {
+        profile.valid = true;
+        if (R_SUCCEEDED(accountProfileGet(profile.get(), nullptr, &base))) {
+            user.name = std::string(base.nickname);
         }
-        accountProfileClose(&profile);
     }
     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});
+    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) {
@@ -95,46 +73,23 @@ std::string Account::iconPath(AccountUid id) {
     mkdir("sdmc:/switch/NXST", 0755);
     mkdir("sdmc:/switch/NXST/cache", 0755);
 
-    AccountProfile profile;
-    if (R_FAILED(accountGetProfile(&profile, id)))
+    nxst::AccountProfileHandle profile;
+    if (R_FAILED(accountGetProfile(profile.get(), id)))
+        return "";
+    profile.valid = true;
+
+    u32 img_size = 0;
+    if (R_FAILED(accountProfileGetImageSize(profile.get(), &img_size)) || img_size == 0)
         return "";
 
-    u32 imgSize = 0;
-    if (R_FAILED(accountProfileGetImageSize(&profile, &imgSize)) || imgSize == 0) {
-        accountProfileClose(&profile);
-        return "";
-    }
-
-    std::vector<u8> buf(imgSize);
-    u32 outSize = 0;
-    Result r = accountProfileLoadImage(&profile, buf.data(), imgSize, &outSize);
-    accountProfileClose(&profile);
-    if (R_FAILED(r) || 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 "";
 
-    FILE* f = fopen(path, "wb");
+    nxst::FileHandle f(fopen(path, "wb"));
     if (!f)
         return "";
-    fwrite(buf.data(), 1, outSize, f);
-    fclose(f);
+    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{};
-}

src/domain/common.cpp

@@ -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);
-}

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 = StringUtils::containsInvalidChar(name) ? StringUtils::format("0x%016llX", m_id)
+                                                         : StringUtils::removeForbiddenCharacters(name);
+    m_path = "sdmc:/switch/NXST/saves/" + StringUtils::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 = StringUtils::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);
+        StringUtils::trim(head);
+        StringUtils::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);
+            StringUtils::trim(head);
+            StringUtils::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 StringUtils::format("%d", minutes / 60) + ":" + StringUtils::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(StringUtils::format("0x%016llX", title.id()), title.name());
         }
     }
     return map;

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();
+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);
+        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 StringUtils::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 StringUtils::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 StringUtils::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 StringUtils::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 StringUtils::ltrim(std::string& s) {
+    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char c) {
+                return !std::isspace(c);
+            }));
+}
+
+void StringUtils::rtrim(std::string& s) {
+    s.erase(std::find_if(s.rbegin(), s.rend(),
+                         [](unsigned char c) {
+                             return !std::isspace(c);
+                         })
+                .base(),
+            s.end());
+}
+
+void StringUtils::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 StringUtils::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 result;
+}
 
-    return UTF16toUTF8(src);
+// Replaces Latin characters with diacritics with their ASCII base equivalents.
+std::string StringUtils::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 StringUtils::UTF16toUTF8(wide);
 }
 
 std::string StringUtils::removeNotAscii(std::string str) {
-    for (size_t i = 0, sz = str.length(); i < sz; i++) {
-        if (!isascii(str[i])) {
-            str[i] = ' ';
-        }
+    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 StringUtils::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]);
         }
     }
 }

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();
-}

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 FileSystem::mount(FsFileSystem* fs, u64 title_id, AccountUid uid) {
+    return fsOpen_SaveData(fs, title_id, uid);
 }
 
 int FileSystem::mount(FsFileSystem fs) {
     return fsdevMountDevice("save", fs);
 }
 
-void FileSystem::unmount(void) {
+void FileSystem::unmount() {
     fsdevUnmountDevice("save");
-}
+}

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,23 +135,23 @@ 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 = FileSystem::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 (FileSystem::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();
         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())));
@@ -177,19 +161,26 @@ nxst::Result<std::string> io::backup(size_t index, AccountUid uid) {
     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();
+        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)) {
         FileSystem::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();
@@ -233,10 +224,41 @@ static void createSaveIfNeeded(u64 title_id, AccountUid uid) {
     fsCreateSaveDataFileSystem(&attr, &create_info, &meta);
 }
 
-nxst::Result<std::string> io::restore(size_t index, AccountUid uid, size_t cellIndex,
-                                      const std::string& nameFromCell) {
-    (void)cellIndex;
+static nxst::Result<void> clearSaveRoot(const std::string& dst_path) {
+    Directory save_root(dst_path);
+    for (size_t i = 0, sz = save_root.size(); i < sz; i++) {
+        if (save_root.folder(i)) {
+            io::deleteFolderRecursively(dst_path + save_root.entry(i) + "/");
+            rmdir((dst_path + save_root.entry(i)).c_str());
+        } else {
+            std::remove((dst_path + save_root.entry(i)).c_str());
+        }
+    }
 
+    Result res = fsdevCommitDevice("save");
+    if (R_FAILED(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();
+}
+
+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%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%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, const std::string& title_name) {
     Title title;
     getTitle(title, uid, index);
 
@@ -245,23 +267,23 @@ 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 = FileSystem::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 (FileSystem::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();
         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 src_path = title.path() + "/" + suggestion + "/";
@@ -276,42 +298,21 @@ nxst::Result<std::string> io::restore(size_t index, AccountUid uid, size_t cellI
         }
     }
 
-    {
-        Directory save_root(dst_path);
-        for (size_t i = 0, sz = save_root.size(); i < sz; i++) {
-            if (save_root.folder(i)) {
-                io::deleteFolderRecursively(dst_path + save_root.entry(i) + "/");
-                rmdir((dst_path + save_root.entry(i)).c_str());
-            } else {
-                std::remove((dst_path + save_root.entry(i)).c_str());
-            }
-        }
+    auto clear_res = clearSaveRoot(dst_path);
+    if (!clear_res.isOk()) {
+        FileSystem::unmount();
+        return nxst::Result<std::string>::failure(clear_res.error());
     }
 
-    res = fsdevCommitDevice("save");
-    if (R_FAILED(res)) {
+    auto extract_res = extractAndCommit(src_path, dst_path);
+    if (!extract_res.isOk()) {
         FileSystem::unmount();
-        nxst::log::error("Failed to commit save after clearing with result 0x%08lX.", res);
-        return nxst::Result<std::string>::failure("Failed to commit save after delete.");
-    }
-
-    res = io::copyDirectory(src_path, dst_path);
-    if (R_FAILED(res)) {
-        FileSystem::unmount();
-        nxst::log::error("Failed to copy %s to save:/ with result 0x%08lX.", src_path.c_str(), res);
-        return nxst::Result<std::string>::failure("Failed to restore save.");
-    }
-
-    res = fsdevCommitDevice("save");
-    if (R_FAILED(res)) {
-        FileSystem::unmount();
-        nxst::log::error("Failed to commit save with result 0x%08lX.", res);
-        return nxst::Result<std::string>::failure("Failed to commit to save device.");
+        return nxst::Result<std::string>::failure(extract_res.error());
     }
 
     blinkLed(4);
     FileSystem::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.");
 }

src/infra/net/transfer_receiver.cpp

@@ -1 +0,0 @@
-// Logic moved to src/service/transfer_service.cpp

src/infra/net/transfer_sender.cpp

@@ -1 +0,0 @@
-// Logic moved to src/service/transfer_service.cpp

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

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 =
+            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);
+#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

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(StringUtils::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

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