DragonSpirit/NXST
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ui improve

Browse Source
This commit is contained in:
Nikolai Fedorov
2026-04-25 10:34:50 +03:00
parent 7515e0334b
commit a2e874de85
9 changed files with 162 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/Main.cpp
+1
View File
@@ -60,5 +60,6 @@ int main() {
main->Show();
servicesExit();
return 0;
}
source/TitlesLayout.cpp
+48 -19
View File
@@ -26,7 +26,11 @@ namespace ui {
}
void TitlesLayout::onInput(u64 Down, u64 Up, u64 Held, pu::ui::TouchPoint Pos) {
if (m_inputLocked) return;
if (Down & HidNpadButton_Plus) {
cancelClientTransfer();
cancelServerTransfer();
mainApp->Close();
return;
}
@@ -42,14 +46,24 @@ namespace ui {
switch (opt) {
case 0: {
// Transfer selected
auto result = io::backup(index, g_currentUId);
if (std::get<0>(result)) {
printf("path is %s\n", std::get<2>(result).c_str());
std::string path = std::get<2>(result);
auto directory = std::filesystem::path(path);
transfer_files(directory);
auto backupResult = io::backup(index, g_currentUId);
if (!std::get<0>(backupResult)) {
mainApp->CreateShowDialog("Transfer", "Failed to create backup:\n" + std::get<2>(backupResult), {"OK"}, true);
break;
}
auto directory = std::filesystem::path(std::get<2>(backupResult));
{
auto ovl = TransferOverlay::New("Transferring save data...");
this->titlesMenu->SetVisible(false);
mainApp->StartOverlay(ovl);
this->LockInput();
if (transfer_files(directory) != 0) {
mainApp->EndOverlay();
this->titlesMenu->SetVisible(true);
this->UnlockInput();
mainApp->CreateShowDialog("Transfer", "Failed to start transfer.", {"OK"}, true);
break;
}
while (!isClientTransferDone()) {
ovl->SetStatus(getClientStatusText());
ovl->SetProgress(getClientProgress());
@@ -60,17 +74,29 @@ namespace ui {
svcSleepThread(16666666LL);
}
mainApp->EndOverlay();
this->titlesMenu->SetVisible(true);
this->UnlockInput();
}
if (isClientConnectionFailed()) {
mainApp->CreateShowDialog("Transfer", "No receiver found.\nMake sure the other Switch is in Receive mode.", {"OK"}, true);
} else if (isClientTransferCancelled()) {
mainApp->CreateShowDialog("Transfer", "Transfer cancelled.", {"OK"}, true);
} else {
mainApp->CreateShowDialog("Transfer", "Save data sent successfully!", {"OK"}, true);
}
break;
}
case 1: {
// Receive selected
printf("startSendingThread\n");
int result = startSendingThread();
printf("result is %i\n", result);
if (result == 0) {
if (startSendingThread() != 0) {
mainApp->CreateShowDialog("Receive", "Failed to start receiver.\nCheck network connection.", {"OK"}, true);
break;
}
{
auto ovl = TransferOverlay::New("Receiving save data...");
this->titlesMenu->SetVisible(false);
mainApp->StartOverlay(ovl);
this->LockInput();
while (!isServerTransferDone()) {
ovl->SetStatus(getServerStatusText());
ovl->SetProgress(getServerProgress());
@@ -81,16 +107,19 @@ namespace ui {
svcSleepThread(16666666LL);
}
mainApp->EndOverlay();
if (!isServerTransferCancelled()) {
auto restoreResult = io::restore(index, g_currentUId, 0, title.name());
if (std::get<0>(restoreResult)) {
printf("%s\n", std::get<2>(restoreResult).c_str());
} else {
printf("Failed to restore with error %s\n", std::get<2>(restoreResult).c_str());
}
}
this->titlesMenu->SetVisible(true);
this->UnlockInput();
}
if (isServerTransferCancelled()) {
mainApp->CreateShowDialog("Receive", "Transfer cancelled.", {"OK"}, true);
break;
}
auto restoreResult = io::restore(index, g_currentUId, 0, title.name());
if (std::get<0>(restoreResult)) {
mainApp->CreateShowDialog("Receive", "Save data received and restored successfully!", {"OK"}, true);
} else {
mainApp->CreateShowDialog("Receive", "Restore failed:\n" + std::get<2>(restoreResult), {"OK"}, true);
}
break;
}
}
source/client.cpp
+84 -65
View File
@@ -1,6 +1,8 @@
#include <arpa/inet.h>
#include <chrono>
#include <cstring>
#include <filesystem>
#include <sys/select.h>
#include <fstream>
#include <iostream>
#include <netinet/in.h>
@@ -24,15 +26,12 @@ using path = fs::path;
static TransferState g_client_state;
bool isClientTransferDone() { return g_client_state.done.load(); }
void cancelClientTransfer() { g_client_state.cancelled.store(true); }
double getClientProgress() { return g_client_state.progress(); }
std::string getClientStatusText() { return g_client_state.getStatus(); }
struct ThreadArgs {
int sock;
fs::path directory;
};
bool isClientTransferDone() { return g_client_state.done.load(); }
bool isClientTransferCancelled() { return g_client_state.cancelled.load(); }
bool isClientConnectionFailed() { return g_client_state.connection_failed.load(); }
void cancelClientTransfer() { g_client_state.cancelled.store(true); }
double getClientProgress() { return g_client_state.progress(); }
std::string getClientStatusText() { return g_client_state.getStatus(); }
static bool send_all(int sock, const void* buf, size_t len) {
size_t sent = 0;
@@ -79,37 +78,64 @@ static bool sendFile(int sock, const fs::path& filepath) {
return true;
}
static void* send_files_thread(void* arg) {
ThreadArgs* targs = static_cast<ThreadArgs*>(arg);
int sock = targs->sock;
fs::path cwd = targs->directory;
delete targs;
static int find_server(char* server_ip);
for (const auto& entry : fs::recursive_directory_iterator(cwd)) {
static void fail_connect() {
g_client_state.connection_failed.store(true);
g_client_state.done.store(true);
}
static void* discovery_and_send_thread(void* arg) {
fs::path directory = *static_cast<fs::path*>(arg);
delete static_cast<fs::path*>(arg);
char server_ip[INET_ADDRSTRLEN];
if (find_server(server_ip) != 0) {
if (!g_client_state.cancelled.load()) fail_connect();
g_client_state.done.store(true);
return nullptr;
}
if (g_client_state.cancelled.load()) { g_client_state.done.store(true); return nullptr; }
g_client_state.setStatus("Connecting...");
Socket tcp(socket(AF_INET, SOCK_STREAM, 0));
if (!tcp.valid()) { fail_connect(); return nullptr; }
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, (sockaddr*)&serv, sizeof(serv)) < 0) {
fail_connect();
return nullptr;
}
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());
g_client_state.bytes_total.store(total);
for (const auto& entry : fs::recursive_directory_iterator(directory)) {
if (g_client_state.cancelled.load()) break;
const path& p = entry.path();
if (fs::is_regular_file(p)) {
g_client_state.setStatus(p.filename().string());
if (!sendFile(sock, p)) break;
if (!sendFile(tcp.fd, p)) break;
}
}
// EOF sentinel — server reads this and exits its receive loop cleanly
uint32_t sentinel = proto::EOF_SENTINEL;
send_all(sock, &sentinel, sizeof(sentinel));
send_all(tcp.fd, &sentinel, sizeof(sentinel));
g_client_state.setStatus("");
close(sock);
g_client_state.done.store(true);
return nullptr;
}
static int find_server(char* server_ip) {
Socket udp(socket(AF_INET, SOCK_DGRAM, 0));
if (!udp.valid()) {
std::cerr << "find_server: socket failed" << std::endl;
return -1;
}
int udp_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (udp_fd < 0) return -1;
sockaddr_in addr{};
addr.sin_family = AF_INET;
@@ -117,57 +143,50 @@ static int find_server(char* server_ip) {
addr.sin_addr.s_addr = inet_addr(proto::MULTICAST_GROUP);
const char* msg = "DISCOVER_SERVER";
if (sendto(udp, msg, strlen(msg), 0, (sockaddr*)&addr, sizeof(addr)) < 0) {
std::cerr << "find_server: sendto failed" << std::endl;
if (sendto(udp_fd, msg, strlen(msg), 0, (sockaddr*)&addr, sizeof(addr)) < 0) {
close(udp_fd);
return -1;
}
sockaddr_in from{};
socklen_t fromlen = sizeof(from);
char buf[256];
ssize_t n = recvfrom(udp, buf, sizeof(buf) - 1, 0, (sockaddr*)&from, &fromlen);
if (n < 0) {
std::cerr << "find_server: recvfrom failed" << std::endl;
return -1;
// Poll in 100ms slices so we can react to cancel within 100ms
auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(3);
while (std::chrono::steady_clock::now() < deadline) {
if (g_client_state.cancelled.load()) {
close(udp_fd);
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, server_ip, INET_ADDRSTRLEN);
close(udp_fd);
return 0;
}
}
}
}
buf[n] = '\0';
if (strcmp(buf, "SERVER_HERE") != 0) {
std::cerr << "find_server: unexpected response: " << buf << std::endl;
return -1;
}
inet_ntop(AF_INET, &from.sin_addr, server_ip, INET_ADDRSTRLEN);
return 0;
close(udp_fd);
return -1;
}
int transfer_files(fs::path directory) {
char server_ip[INET_ADDRSTRLEN];
if (find_server(server_ip) != 0) return -1;
Socket tcp(socket(AF_INET, SOCK_STREAM, 0));
if (!tcp.valid()) return -1;
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) return -1;
if (connect(tcp, (sockaddr*)&serv, sizeof(serv)) < 0) return -1;
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());
}
g_client_state.reset();
g_client_state.bytes_total.store(total);
g_client_state.setStatus("Connecting...");
ThreadArgs* args = new ThreadArgs{tcp.fd, directory};
tcp.release(); // ownership transferred to thread
g_client_state.setStatus("Searching for receiver...");
fs::path* arg = new fs::path(directory);
pthread_t thread;
if (pthread_create(&thread, nullptr, send_files_thread, args) != 0) {
delete args;
if (pthread_create(&thread, nullptr, discovery_and_send_thread, arg) != 0) {
delete arg;
return -1;
}
pthread_detach(thread);
source/server.cpp
+8
View File
@@ -24,6 +24,7 @@
static TransferState g_server_state;
static std::atomic<int> g_server_client_sock{-1};
static std::atomic<int> g_server_listen_sock{-1};
static std::atomic<int> g_broadcast_sock{-1};
bool isServerTransferDone() { return g_server_state.done.load(); }
@@ -35,6 +36,8 @@ void cancelServerTransfer() {
g_server_state.cancelled.store(true);
int sock = g_server_client_sock.load();
if (sock >= 0) shutdown(sock, SHUT_RDWR);
int lsock = g_server_listen_sock.load();
if (lsock >= 0) shutdown(lsock, SHUT_RDWR);
int bsock = g_broadcast_sock.load();
if (bsock >= 0) shutdown(bsock, SHUT_RDWR);
}
@@ -173,9 +176,11 @@ static void* accept_and_handle(void* arg) {
int server_fd = static_cast<AcceptArgs*>(arg)->server_fd;
delete static_cast<AcceptArgs*>(arg);
g_server_listen_sock.store(server_fd);
sockaddr_in client_addr{};
socklen_t client_len = sizeof(client_addr);
int client_socket = accept(server_fd, (sockaddr*)&client_addr, &client_len);
g_server_listen_sock.store(-1);
close(server_fd);
if (client_socket >= 0) {
@@ -256,6 +261,9 @@ int startSendingThread() {
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;
source/util.cpp
-15
View File
@@ -32,10 +32,7 @@
void servicesExit(void)
{
Logger::getInstance().flush();
pdmqryExit();
socketExit();
Account::exit();
nsExit();
plExit();
romfsExit();
}
@@ -79,18 +76,6 @@ Result servicesInit(void)
return res;
}
if (R_FAILED(res = nsInitialize())) {
Logger::getInstance().log(Logger::ERROR, "nsInitialize failed. Result code 0x%08lX.", res);
return res;
}
// Configuration::getInstance();
if (R_SUCCEEDED(res = pdmqryInitialize())) {}
else {
Logger::getInstance().log(Logger::WARN, "pdmqryInitialize failed with result 0x%08lX.", res);
}
Logger::getInstance().log(Logger::INFO, "NXST loading completed!");
return 0;