From 5dfd0ef9f57470aa798098ab8f744fc01db793c5 Mon Sep 17 00:00:00 2001 From: shen Date: Sat, 12 Sep 2026 12:30:21 +0800 Subject: [PATCH] feat: implement M2 emulator foundation --- .gitignore | 1 + README.md | 5 +- app/build.gradle.kts | 7 +- app/src/main/cpp/CMakeLists.txt | 12 +- app/src/main/cpp/cmake/fceumm.cmake | 99 ++++ app/src/main/cpp/core_identity.cpp | 15 + app/src/main/cpp/core_identity.h | 9 + app/src/main/cpp/core_session.cpp | 465 ++++++++++++++++++ app/src/main/cpp/core_session.h | 22 + app/src/main/cpp/gl_renderer.cpp | 107 ++++ app/src/main/cpp/jni_bridge.cpp | 63 +++ app/src/main/cpp/session_rules.cpp | 37 ++ app/src/main/cpp/session_rules.h | 16 + app/src/main/cpp/tests/native_smoke_test.cpp | 28 +- app/src/main/cpp/video_buffer.cpp | 36 ++ app/src/main/cpp/video_buffer.h | 30 ++ .../java/org/neslite/app/EmulatorSurface.kt | 25 + .../main/java/org/neslite/app/MainActivity.kt | 195 +++++++- .../main/java/org/neslite/app/NativeBridge.kt | 16 + .../java/org/neslite/app/library/GameDao.java | 22 + .../org/neslite/app/library/GameDatabase.java | 29 ++ .../org/neslite/app/library/GameEntity.java | 36 ++ .../neslite/app/library/LibraryRecovery.kt | 66 +++ .../java/org/neslite/app/library/NesHeader.kt | 21 + .../org/neslite/app/library/RomImporter.kt | 78 +++ .../neslite/app/library/RomStreamCopier.kt | 45 ++ .../java/org/neslite/app/BuildIdentityTest.kt | 4 +- .../org/neslite/app/library/NesHeaderTest.kt | 38 ++ .../app/library/RomStreamCopierTest.kt | 45 ++ docs/architecture.md | 54 ++ docs/build.md | 8 +- docs/identity.md | 2 +- docs/reports/m2-foundation.md | 37 ++ gradle/libs.versions.toml | 1 + todo.md | 4 + 35 files changed, 1663 insertions(+), 15 deletions(-) create mode 100644 app/src/main/cpp/cmake/fceumm.cmake create mode 100644 app/src/main/cpp/core_identity.cpp create mode 100644 app/src/main/cpp/core_identity.h create mode 100644 app/src/main/cpp/core_session.cpp create mode 100644 app/src/main/cpp/core_session.h create mode 100644 app/src/main/cpp/gl_renderer.cpp create mode 100644 app/src/main/cpp/session_rules.cpp create mode 100644 app/src/main/cpp/session_rules.h create mode 100644 app/src/main/cpp/video_buffer.cpp create mode 100644 app/src/main/cpp/video_buffer.h create mode 100644 app/src/main/java/org/neslite/app/EmulatorSurface.kt create mode 100644 app/src/main/java/org/neslite/app/library/GameDao.java create mode 100644 app/src/main/java/org/neslite/app/library/GameDatabase.java create mode 100644 app/src/main/java/org/neslite/app/library/GameEntity.java create mode 100644 app/src/main/java/org/neslite/app/library/LibraryRecovery.kt create mode 100644 app/src/main/java/org/neslite/app/library/NesHeader.kt create mode 100644 app/src/main/java/org/neslite/app/library/RomImporter.kt create mode 100644 app/src/main/java/org/neslite/app/library/RomStreamCopier.kt create mode 100644 app/src/test/java/org/neslite/app/library/NesHeaderTest.kt create mode 100644 app/src/test/java/org/neslite/app/library/RomStreamCopierTest.kt create mode 100644 docs/architecture.md create mode 100644 docs/reports/m2-foundation.md diff --git a/.gitignore b/.gitignore index 35c749f..8560093 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ .gradle/ +.kotlin/ .idea/ .cxx/ **/.cxx/ diff --git a/README.md b/README.md index 896f07d..b7c28e7 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,8 @@ # NESLite NESLite 是一个面向 Android 的轻量 NES/FC 模拟器前端。它使用固定版本的 -FCEUmm libretro 内核;当前仓库已完成 M1 诊断版实现,等待目标手机和 X5 Lite 实机验收。 +FCEUmm libretro 内核。当前仓库已完成 M2 的隔离实现和本地验证;由于 G1 尚未经过目标手机与 +X5 Lite 验收,M2/G2 的实机门槛仍保持未通过。 ## 快速构建 @@ -13,7 +14,7 @@ pwsh -NoProfile -File .\tools\check.ps1 -Scope Build 该命令默认只生成 arm64-v8a 调试 APK,不会运行耐久或实机验收。 -连接并授权目标手机后,可用 `tools/check-m1-device.ps1` 安装和启动 0.1.3 诊断 APK;实测步骤见 +连接并授权目标手机后,可用 `tools/check-m1-device.ps1` 安装和启动当前调试 APK;实测步骤见 [X5 Lite 键位表](docs/controller-x5lite.md)。 ## 许可证 diff --git a/app/build.gradle.kts b/app/build.gradle.kts index a19afe9..383f006 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -21,8 +21,8 @@ android { applicationId = "org.neslite.app" minSdk = 28 targetSdk = 36 - versionCode = 1003 - versionName = "0.1.3" + versionCode = 2004 + versionName = "0.2.4" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" ndk { @@ -71,6 +71,9 @@ kotlin { dependencies { implementation(libs.androidx.core.ktx) implementation(libs.androidx.activity.ktx) + implementation(libs.androidx.room.runtime) + implementation(libs.androidx.room.ktx) + annotationProcessor(libs.androidx.room.compiler) testImplementation(libs.junit) testImplementation(libs.json) diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt index 6c0ab98..28e57a5 100644 --- a/app/src/main/cpp/CMakeLists.txt +++ b/app/src/main/cpp/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 3.22.1) -project(neslite_jni LANGUAGES CXX) +project(neslite_jni LANGUAGES C CXX) set(CMAKE_CXX_STANDARD 20) set(CMAKE_CXX_STANDARD_REQUIRED ON) @@ -7,6 +7,8 @@ set(CMAKE_CXX_EXTENSIONS OFF) set(NESLITE_COMMON_SOURCES native_smoke.cpp + session_rules.cpp + video_buffer.cpp ) function(neslite_enable_strict_warnings target) @@ -18,14 +20,20 @@ function(neslite_enable_strict_warnings target) endfunction() if(ANDROID) + include(cmake/fceumm.cmake) add_library(neslite_jni SHARED + core_identity.cpp + core_session.cpp + gl_renderer.cpp jni_bridge.cpp ${NESLITE_COMMON_SOURCES} ) neslite_enable_strict_warnings(neslite_jni) + target_include_directories(neslite_jni PRIVATE "${NESLITE_LIBRETRO_HEADERS_DIR}") find_library(log-lib log) - target_link_libraries(neslite_jni PRIVATE ${log-lib}) + find_library(gles-lib GLESv2) + target_link_libraries(neslite_jni PRIVATE fceumm_core ${log-lib} ${gles-lib}) else() enable_testing() add_executable(neslite_native_smoke_test diff --git a/app/src/main/cpp/cmake/fceumm.cmake b/app/src/main/cpp/cmake/fceumm.cmake new file mode 100644 index 0000000..5c1d89a --- /dev/null +++ b/app/src/main/cpp/cmake/fceumm.cmake @@ -0,0 +1,99 @@ +set(NESLITE_FCEUMM_DIR + "${CMAKE_CURRENT_LIST_DIR}/../../../../../third_party/sources/libretro-fceumm" + CACHE PATH "Path to the pinned FCEUmm checkout" +) +set(NESLITE_LIBRETRO_HEADERS_DIR + "${CMAKE_CURRENT_LIST_DIR}/../../../../../third_party/sources/libretro-headers/libretro-common/include" + CACHE PATH "Path to the pinned libretro public headers" +) + +if(NOT EXISTS "${NESLITE_FCEUMM_DIR}/src/drivers/libretro/libretro.c") + message(FATAL_ERROR + "Pinned FCEUmm source not found at ${NESLITE_FCEUMM_DIR}. " + "Run tools/fetch-third-party.ps1 from the repository root." + ) +endif() +if(NOT EXISTS "${NESLITE_LIBRETRO_HEADERS_DIR}/libretro.h") + message(FATAL_ERROR + "Pinned libretro header not found at ${NESLITE_LIBRETRO_HEADERS_DIR}. " + "Run tools/fetch-third-party.ps1 from the repository root." + ) +endif() + +set(FCEUMM_SRC "${NESLITE_FCEUMM_DIR}/src") +set(FCEUMM_LIBRETRO_COMMON "${FCEUMM_SRC}/drivers/libretro/libretro-common") + +file(GLOB FCEUMM_BOARD_SOURCES CONFIGURE_DEPENDS "${FCEUMM_SRC}/boards/*.c") +file(GLOB FCEUMM_INPUT_SOURCES CONFIGURE_DEPENDS "${FCEUMM_SRC}/input/*.c") + +set(FCEUMM_SOURCES + ${FCEUMM_BOARD_SOURCES} + ${FCEUMM_INPUT_SOURCES} + "${FCEUMM_SRC}/drivers/libretro/libretro.c" + "${FCEUMM_SRC}/drivers/libretro/libretro_dipswitch.c" + "${FCEUMM_SRC}/cart.c" + "${FCEUMM_SRC}/cheat.c" + "${FCEUMM_SRC}/crc32.c" + "${FCEUMM_SRC}/fceu-endian.c" + "${FCEUMM_SRC}/fceu-memory.c" + "${FCEUMM_SRC}/fceu.c" + "${FCEUMM_SRC}/fds.c" + "${FCEUMM_SRC}/fds_apu.c" + "${FCEUMM_SRC}/file.c" + "${FCEUMM_SRC}/filter.c" + "${FCEUMM_SRC}/general.c" + "${FCEUMM_SRC}/input.c" + "${FCEUMM_SRC}/md5.c" + "${FCEUMM_SRC}/nsf.c" + "${FCEUMM_SRC}/ntsc/nes_ntsc.c" + "${FCEUMM_SRC}/palette.c" + "${FCEUMM_SRC}/ppu.c" + "${FCEUMM_SRC}/sound.c" + "${FCEUMM_SRC}/state.c" + "${FCEUMM_SRC}/video.c" + "${FCEUMM_SRC}/vsuni.c" + "${FCEUMM_SRC}/ines.c" + "${FCEUMM_SRC}/unif.c" + "${FCEUMM_SRC}/x6502.c" + "${FCEUMM_LIBRETRO_COMMON}/compat/compat_posix_string.c" + "${FCEUMM_LIBRETRO_COMMON}/compat/compat_snprintf.c" + "${FCEUMM_LIBRETRO_COMMON}/compat/compat_strcasestr.c" + "${FCEUMM_LIBRETRO_COMMON}/compat/compat_strl.c" + "${FCEUMM_LIBRETRO_COMMON}/compat/fopen_utf8.c" + "${FCEUMM_LIBRETRO_COMMON}/encodings/encoding_utf.c" + "${FCEUMM_LIBRETRO_COMMON}/file/file_path.c" + "${FCEUMM_LIBRETRO_COMMON}/file/file_path_io.c" + "${FCEUMM_LIBRETRO_COMMON}/streams/file_stream.c" + "${FCEUMM_LIBRETRO_COMMON}/streams/file_stream_transforms.c" + "${FCEUMM_LIBRETRO_COMMON}/streams/memory_stream.c" + "${FCEUMM_LIBRETRO_COMMON}/string/stdstring.c" + "${FCEUMM_LIBRETRO_COMMON}/time/rtime.c" + "${FCEUMM_LIBRETRO_COMMON}/vfs/vfs_implementation.c" +) + +add_library(fceumm_core STATIC ${FCEUMM_SOURCES}) +set_target_properties(fceumm_core PROPERTIES POSITION_INDEPENDENT_CODE ON) +target_include_directories(fceumm_core PUBLIC + "${FCEUMM_SRC}/drivers/libretro" + "${FCEUMM_LIBRETRO_COMMON}/include" + "${FCEUMM_SRC}" + "${FCEUMM_SRC}/input" + "${FCEUMM_SRC}/boards" + "${FCEUMM_SRC}/ntsc" +) +target_compile_definitions(fceumm_core PRIVATE + __LIBRETRO__ + PATH_MAX=1024 + FCEU_VERSION_NUMERIC=9900 + FRONTEND_SUPPORTS_RGB565 + HAVE_NTSC_FILTER + PSS_STYLE=1 + GIT_VERSION="236ccdf" +) +target_compile_options(fceumm_core PRIVATE + -Wno-missing-prototypes + -Wno-sign-compare + -Wno-undef + -Wno-unused-parameter +) +target_link_libraries(fceumm_core PUBLIC m) diff --git a/app/src/main/cpp/core_identity.cpp b/app/src/main/cpp/core_identity.cpp new file mode 100644 index 0000000..43f8f18 --- /dev/null +++ b/app/src/main/cpp/core_identity.cpp @@ -0,0 +1,15 @@ +#include "core_identity.h" + +#include + +namespace neslite { + +std::string core_identity() { + retro_system_info info{}; + retro_get_system_info(&info); + const std::string name = info.library_name != nullptr ? info.library_name : "unknown"; + const std::string version = info.library_version != nullptr ? info.library_version : "unknown"; + return name + " " + version + " / libretro API " + std::to_string(retro_api_version()); +} + +} // namespace neslite diff --git a/app/src/main/cpp/core_identity.h b/app/src/main/cpp/core_identity.h new file mode 100644 index 0000000..9c260f6 --- /dev/null +++ b/app/src/main/cpp/core_identity.h @@ -0,0 +1,9 @@ +#pragma once + +#include + +namespace neslite { + +std::string core_identity(); + +} // namespace neslite diff --git a/app/src/main/cpp/core_session.cpp b/app/src/main/cpp/core_session.cpp new file mode 100644 index 0000000..979ca03 --- /dev/null +++ b/app/src/main/cpp/core_session.cpp @@ -0,0 +1,465 @@ +#include "core_session.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "libretro.h" +#include "session_rules.h" + +namespace neslite { +namespace { + +constexpr std::size_t kMaxCommands = 32; +constexpr std::size_t kMaxRomBytes = 64U * 1024U * 1024U; + +struct Command { + std::uint64_t session_id; + std::string name; + std::string rom_path; + std::string system_dir; + std::string save_dir; + std::string rom_hash; +}; + +struct Host { + std::mutex mutex; + std::condition_variable wake; + std::deque commands; + std::thread worker; + std::atomic joypad{0}; + std::atomic issued_session{0}; + std::atomic state{SessionState::Idle}; + std::atomic session_id{0}; + std::uint64_t completion_id = 0; + std::string completion; + std::string error; + std::string system_dir; + std::string save_dir; + std::string rom_hash; + std::map variables; + std::vector rom; + std::string rom_path; + retro_pixel_format pixel_format = RETRO_PIXEL_FORMAT_RGB565; + retro_system_av_info av{}; + bool initialized = false; + bool loaded = false; + VideoBuffer video; + + Host() : worker([this] { run(); }) {} + ~Host() { + { + std::lock_guard lock(mutex); + commands.clear(); + commands.push_back(Command{0, "shutdown", {}, {}, {}, {}}); + wake.notify_one(); + } + if (worker.joinable()) worker.join(); + } + + bool enqueue(Command command) { + std::lock_guard lock(mutex); + if (commands.size() >= kMaxCommands) return false; + commands.push_back(std::move(command)); + wake.notify_one(); + return true; + } + + void set_state(SessionState next) { + state.store(next, std::memory_order_release); + } + + void complete(std::uint64_t id, std::string result) { + std::lock_guard lock(mutex); + ++completion_id; + completion = std::to_string(id) + ":" + std::move(result); + } + + void fail(std::uint64_t id, std::string message) { + { + std::lock_guard lock(mutex); + state.store(SessionState::Error, std::memory_order_release); + error = std::move(message); + } + complete(id, "error"); + } + + bool read_rom(const std::string& path) { + std::ifstream input(path, std::ios::binary); + if (!input) return false; + input.seekg(0, std::ios::end); + const auto length = input.tellg(); + if (length <= 0 || length > static_cast(kMaxRomBytes)) return false; + input.seekg(0, std::ios::beg); + rom.resize(static_cast(length)); + input.read(reinterpret_cast(rom.data()), length); + return input.good(); + } + + void load_battery() { + void* memory = retro_get_memory_data(RETRO_MEMORY_SAVE_RAM); + const std::size_t size = retro_get_memory_size(RETRO_MEMORY_SAVE_RAM); + if (memory == nullptr || size == 0 || rom_hash.empty()) return; + const auto path = std::filesystem::path(save_dir) / rom_hash / "battery" / "battery.sav"; + std::ifstream input(path, std::ios::binary); + if (!input) return; + input.read(static_cast(memory), static_cast(size)); + } + + bool save_battery() { + void* memory = retro_get_memory_data(RETRO_MEMORY_SAVE_RAM); + const std::size_t size = retro_get_memory_size(RETRO_MEMORY_SAVE_RAM); + if (memory == nullptr || size == 0 || rom_hash.empty()) return false; + // Snapshot libretro-owned memory on the core thread; only the copy crosses to file I/O. + std::vector snapshot(size); + std::copy_n(static_cast(memory), size, snapshot.data()); + const auto final_path = std::filesystem::path(save_dir) / rom_hash / "battery" / "battery.sav"; + bool success = false; + std::thread file_thread([snapshot = std::move(snapshot), final_path, &success] { + std::error_code error_code; + std::filesystem::create_directories(final_path.parent_path(), error_code); + if (error_code) return; + const auto temp_path = final_path.string() + ".tmp"; + { + std::ofstream output(temp_path, std::ios::binary | std::ios::trunc); + output.write(reinterpret_cast(snapshot.data()), + static_cast(snapshot.size())); + if (!output.good()) { + output.close(); + std::filesystem::remove(temp_path, error_code); + return; + } + } + std::filesystem::rename(temp_path, final_path, error_code); + if (error_code) { + std::filesystem::remove(final_path, error_code); + error_code.clear(); + std::filesystem::rename(temp_path, final_path, error_code); + } + success = !error_code; + }); + file_thread.join(); + return success; + } + + bool unload() { + bool battery_saved = false; + if (loaded) { + battery_saved = save_battery(); + retro_unload_game(); + loaded = false; + } + if (initialized) { + retro_deinit(); + initialized = false; + } + rom.clear(); + joypad.store(0, std::memory_order_relaxed); + return battery_saved; + } + + bool perform_load(const Command& command) { + unload(); + session_id.store(command.session_id, std::memory_order_release); + system_dir = command.system_dir; + save_dir = command.save_dir; + rom_hash = command.rom_hash; + rom_path = command.rom_path; + error.clear(); + variables.clear(); + pixel_format = RETRO_PIXEL_FORMAT_RGB565; + set_state(SessionState::Loading); + + std::error_code directory_error; + std::filesystem::create_directories(system_dir, directory_error); + if (!directory_error) std::filesystem::create_directories(save_dir, directory_error); + if (!required_host_capabilities_available(retro_api_version(), RETRO_API_VERSION, + !directory_error && !system_dir.empty() && !save_dir.empty())) { + fail(command.session_id, "Required libretro API or private directories are unavailable"); + return false; + } + + if (!read_rom(rom_path)) { + fail(command.session_id, "ROM file cannot be read or exceeds 64 MiB"); + return false; + } + + retro_set_environment(environment_callback); + retro_set_video_refresh(video_callback); + retro_set_audio_sample(audio_sample_callback); + retro_set_audio_sample_batch(audio_batch_callback); + retro_set_input_poll(input_poll_callback); + retro_set_input_state(input_state_callback); + retro_init(); + initialized = true; + retro_set_controller_port_device(0, RETRO_DEVICE_JOYPAD); + + retro_game_info game{}; + game.path = rom_path.c_str(); + game.data = rom.data(); + game.size = rom.size(); + if (!retro_load_game(&game)) { + unload(); + fail(command.session_id, "FCEUmm rejected the ROM"); + return false; + } + loaded = true; + retro_get_system_av_info(&av); + if (av.geometry.base_width == 0 || av.geometry.base_height == 0 || av.timing.fps <= 1.0) { + unload(); + fail(command.session_id, "FCEUmm returned invalid AV information"); + return false; + } + load_battery(); + set_state(SessionState::Paused); + complete(command.session_id, "loaded"); + return true; + } + + bool handle(Command command) { + if (command.name == "shutdown") { + unload(); + return false; + } + if (command.name == "load") { + perform_load(command); + return true; + } + const std::uint64_t active_id = session_id.load(std::memory_order_acquire); + if (!command_targets_active_session(active_id, command.session_id)) { + complete(command.session_id, "stale"); + return true; + } + if (command.name == "run" && loaded && command_allowed(state.load(), command.name)) { + set_state(SessionState::Running); + complete(active_id, "running"); + } else if (command.name == "pause" && loaded && command_allowed(state.load(), command.name)) { + set_state(SessionState::Pausing); + const bool battery_saved = save_battery(); + set_state(SessionState::Paused); + complete(active_id, battery_saved ? "paused_saved" : "paused"); + } else if (command.name == "reset" && loaded && command_allowed(state.load(), command.name)) { + retro_reset(); + complete(active_id, "reset"); + } else if (command.name == "stop" && (loaded || state == SessionState::Error) && + command_allowed(state.load(), command.name)) { + set_state(SessionState::Stopping); + const bool battery_saved = unload(); + set_state(SessionState::Idle); + complete(active_id, battery_saved ? "stopped_saved" : "stopped"); + } else { + complete(command.session_id, "ignored"); + } + return true; + } + + void run() { + using clock = std::chrono::steady_clock; + auto next_frame = clock::now(); + for (;;) { + Command command{}; + bool has_command = false; + { + std::unique_lock lock(mutex); + if (state != SessionState::Running && commands.empty()) { + wake.wait(lock, [this] { return !commands.empty(); }); + } + if (!commands.empty()) { + command = std::move(commands.front()); + commands.pop_front(); + has_command = true; + } + } + if (has_command) { + if (!handle(std::move(command))) return; + next_frame = clock::now(); + continue; + } + SessionState current; + { + std::lock_guard lock(mutex); + current = state; + } + if (current == SessionState::Running && loaded) { + retro_run(); + const double fps = std::clamp(av.timing.fps, 10.0, 240.0); + next_frame += std::chrono::duration_cast( + std::chrono::duration(1.0 / fps)); + const auto now = clock::now(); + if (next_frame > now) std::this_thread::sleep_until(next_frame); + else if (now - next_frame > std::chrono::milliseconds(250)) next_frame = now; + } + } + } + + static Host& instance() { + static Host host; + return host; + } + + static bool environment_callback(unsigned command, void* data) { + Host& host = instance(); + switch (command) { + case RETRO_ENVIRONMENT_GET_CAN_DUPE: + *static_cast(data) = true; + return true; + case RETRO_ENVIRONMENT_GET_INPUT_BITMASKS: + return true; + case RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY: + *static_cast(data) = host.system_dir.c_str(); + return true; + case RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY: + *static_cast(data) = host.save_dir.c_str(); + return true; + case RETRO_ENVIRONMENT_GET_CONTENT_DIRECTORY: + *static_cast(data) = host.system_dir.c_str(); + return true; + case RETRO_ENVIRONMENT_SET_PIXEL_FORMAT: { + const auto format = *static_cast(data); + if (format != RETRO_PIXEL_FORMAT_RGB565) return false; + host.pixel_format = format; + return true; + } + case RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION: + *static_cast(data) = 0; + return true; + case RETRO_ENVIRONMENT_SET_VARIABLES: { + const auto* variable = static_cast(data); + for (; variable != nullptr && variable->key != nullptr; ++variable) { + std::string value = variable->value == nullptr ? "" : variable->value; + const auto separator = value.find(';'); + if (separator != std::string::npos) value.erase(0, separator + 1); + value.erase(0, value.find_first_not_of(' ')); + const auto pipe = value.find('|'); + host.variables[variable->key] = value.substr(0, pipe); + } + return true; + } + case RETRO_ENVIRONMENT_GET_VARIABLE: { + auto* variable = static_cast(data); + const auto found = host.variables.find(variable->key == nullptr ? "" : variable->key); + variable->value = found == host.variables.end() ? nullptr : found->second.c_str(); + return found != host.variables.end(); + } + case RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE: + *static_cast(data) = false; + return true; + case RETRO_ENVIRONMENT_SET_VARIABLE: { + const auto* variable = static_cast(data); + if (variable == nullptr || variable->key == nullptr || variable->value == nullptr) return false; + host.variables[variable->key] = variable->value; + return true; + } + case RETRO_ENVIRONMENT_GET_LOG_INTERFACE: + static_cast(data)->log = log_callback; + return true; + case RETRO_ENVIRONMENT_GET_LANGUAGE: + *static_cast(data) = RETRO_LANGUAGE_ENGLISH; + return true; + case RETRO_ENVIRONMENT_GET_MESSAGE_INTERFACE_VERSION: + *static_cast(data) = 1; + return true; + case RETRO_ENVIRONMENT_GET_TARGET_REFRESH_RATE: + *static_cast(data) = 60.0F; + return true; + case RETRO_ENVIRONMENT_GET_TARGET_SAMPLE_RATE: + *static_cast(data) = 48000U; + return true; + case RETRO_ENVIRONMENT_SET_GEOMETRY: + host.av.geometry = *static_cast(data); + return true; + case RETRO_ENVIRONMENT_SET_SYSTEM_AV_INFO: + host.av = *static_cast(data); + return true; + case RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL: + case RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS: + case RETRO_ENVIRONMENT_SET_CONTROLLER_INFO: + case RETRO_ENVIRONMENT_SET_CONTENT_INFO_OVERRIDE: + case RETRO_ENVIRONMENT_SET_SUPPORT_ACHIEVEMENTS: + case RETRO_ENVIRONMENT_SET_MEMORY_MAPS: + case RETRO_ENVIRONMENT_SET_MESSAGE: + case RETRO_ENVIRONMENT_SET_MESSAGE_EXT: + return true; + default: + return false; + } + } + + static void video_callback(const void* data, unsigned width, unsigned height, std::size_t pitch) { + Host& host = instance(); + const unsigned bytes_per_pixel = host.pixel_format == RETRO_PIXEL_FORMAT_XRGB8888 ? 4U : 2U; + host.video.submit(data, width, height, pitch, bytes_per_pixel, + static_cast(host.pixel_format)); + } + + static void audio_sample_callback(std::int16_t, std::int16_t) {} + static std::size_t audio_batch_callback(const std::int16_t*, std::size_t frames) { return frames; } + static void input_poll_callback() {} + static std::int16_t input_state_callback(unsigned port, unsigned device, unsigned, unsigned id) { + if (port != 0 || device != RETRO_DEVICE_JOYPAD) return 0; + const std::uint16_t mask = instance().joypad.load(std::memory_order_relaxed); + if (id == RETRO_DEVICE_ID_JOYPAD_MASK) return static_cast(mask); + return id < 16U && (mask & (1U << id)) != 0U ? 1 : 0; + } + static void log_callback(enum retro_log_level level, const char* format, ...) { + android_LogPriority priority = level == RETRO_LOG_ERROR ? ANDROID_LOG_ERROR : ANDROID_LOG_INFO; + va_list arguments; + va_start(arguments, format); + __android_log_vprint(priority, "NESLite/FCEUmm", format, arguments); + va_end(arguments); + } +}; + +} // namespace + +std::uint64_t load_rom(const std::string& rom_path, + const std::string& system_dir, + const std::string& save_dir, + const std::string& rom_hash) { + Host& host = Host::instance(); + const std::uint64_t id = host.issued_session.fetch_add(1) + 1; + if (!host.enqueue(Command{id, "load", rom_path, system_dir, save_dir, rom_hash})) return 0; + return id; +} + +bool session_command(std::uint64_t session_id, const std::string& command) { + if (command != "run" && command != "pause" && command != "reset" && command != "stop") return false; + return Host::instance().enqueue(Command{session_id, command, {}, {}, {}, {}}); +} + +void set_joypad_mask(std::uint16_t mask) { + Host::instance().joypad.store(mask, std::memory_order_relaxed); +} + +std::string session_status_json() { + Host& host = Host::instance(); + std::lock_guard lock(host.mutex); + return "{\"sessionId\":" + std::to_string(host.session_id.load(std::memory_order_acquire)) + + ",\"state\":\"" + session_state_name(host.state.load(std::memory_order_acquire)) + + "\",\"queueDepth\":" + std::to_string(host.commands.size()) + + ",\"completionId\":" + std::to_string(host.completion_id) + + ",\"completion\":\"" + host.completion + + "\",\"error\":\"" + host.error + "\"}"; +} + +bool latest_video_frame(VideoFrame* frame) { + if (frame == nullptr) return false; + Host& host = Host::instance(); + return host.video.latest(frame); +} + +} // namespace neslite diff --git a/app/src/main/cpp/core_session.h b/app/src/main/cpp/core_session.h new file mode 100644 index 0000000..08e97f5 --- /dev/null +++ b/app/src/main/cpp/core_session.h @@ -0,0 +1,22 @@ +#pragma once + +#include +#include + +#include "video_buffer.h" + +namespace neslite { + +// All libretro calls are owned by the implementation's single worker thread. +// UI/JNI callers only enqueue commands and read immutable snapshots. +std::uint64_t load_rom(const std::string& rom_path, + const std::string& system_dir, + const std::string& save_dir, + const std::string& rom_hash); +bool session_command(std::uint64_t session_id, const std::string& command); +void set_joypad_mask(std::uint16_t mask); +std::string session_status_json(); + +bool latest_video_frame(VideoFrame* frame); + +} // namespace neslite diff --git a/app/src/main/cpp/gl_renderer.cpp b/app/src/main/cpp/gl_renderer.cpp new file mode 100644 index 0000000..7222f12 --- /dev/null +++ b/app/src/main/cpp/gl_renderer.cpp @@ -0,0 +1,107 @@ +#include + +#include +#include +#include +#include + +#include "core_session.h" + +namespace neslite { +namespace { +GLuint program = 0; +GLuint texture = 0; +GLint position_location = -1; +GLint texcoord_location = -1; +int surface_width = 1; +int surface_height = 1; +std::uint64_t uploaded_sequence = 0; +unsigned texture_width = 0; +unsigned texture_height = 0; + +GLuint compile_shader(GLenum type, const char* source) { + const GLuint shader = glCreateShader(type); + glShaderSource(shader, 1, &source, nullptr); + glCompileShader(shader); + return shader; +} +} + +void renderer_created() { + constexpr const char* vertex = + "attribute vec2 aPosition; attribute vec2 aTexCoord; varying vec2 vTexCoord;" + "void main(){ gl_Position=vec4(aPosition,0.0,1.0); vTexCoord=aTexCoord; }"; + constexpr const char* fragment = + "precision mediump float; varying vec2 vTexCoord; uniform sampler2D uTexture;" + "void main(){ gl_FragColor=texture2D(uTexture,vTexCoord); }"; + const GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex); + const GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment); + program = glCreateProgram(); + glAttachShader(program, vertex_shader); + glAttachShader(program, fragment_shader); + glLinkProgram(program); + glDeleteShader(vertex_shader); + glDeleteShader(fragment_shader); + position_location = glGetAttribLocation(program, "aPosition"); + texcoord_location = glGetAttribLocation(program, "aTexCoord"); + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + uploaded_sequence = 0; +} + +void renderer_changed(int width, int height) { + surface_width = std::max(1, width); + surface_height = std::max(1, height); +} + +void renderer_draw(bool integer_scale) { + glClearColor(0.02F, 0.02F, 0.02F, 1.0F); + glClear(GL_COLOR_BUFFER_BIT); + VideoFrame frame; + if (!latest_video_frame(&frame)) return; + + glBindTexture(GL_TEXTURE_2D, texture); + if (frame.sequence != uploaded_sequence) { + const GLenum type = frame.pixel_format == 1 ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5; + const GLenum format = frame.pixel_format == 1 ? GL_RGBA : GL_RGB; + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexImage2D(GL_TEXTURE_2D, 0, format, static_cast(frame.width), + static_cast(frame.height), 0, format, type, frame.bytes.data()); + uploaded_sequence = frame.sequence; + texture_width = frame.width; + texture_height = frame.height; + } + if (texture_width == 0 || texture_height == 0) return; + + int viewport_width; + int viewport_height; + if (integer_scale) { + const int scale = std::max(1, std::min(surface_width / static_cast(texture_width), + surface_height / static_cast(texture_height))); + viewport_width = static_cast(texture_width) * scale; + viewport_height = static_cast(texture_height) * scale; + } else { + viewport_width = std::min(surface_width, surface_height * 4 / 3); + viewport_height = viewport_width * 3 / 4; + if (viewport_height > surface_height) { + viewport_height = surface_height; + viewport_width = viewport_height * 4 / 3; + } + } + glViewport((surface_width - viewport_width) / 2, (surface_height - viewport_height) / 2, + viewport_width, viewport_height); + constexpr GLfloat vertices[] = {-1.F, -1.F, 1.F, -1.F, -1.F, 1.F, 1.F, 1.F}; + constexpr GLfloat texcoords[] = {0.F, 1.F, 1.F, 1.F, 0.F, 0.F, 1.F, 0.F}; + glUseProgram(program); + glEnableVertexAttribArray(static_cast(position_location)); + glEnableVertexAttribArray(static_cast(texcoord_location)); + glVertexAttribPointer(static_cast(position_location), 2, GL_FLOAT, GL_FALSE, 0, vertices); + glVertexAttribPointer(static_cast(texcoord_location), 2, GL_FLOAT, GL_FALSE, 0, texcoords); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +} + +} // namespace neslite diff --git a/app/src/main/cpp/jni_bridge.cpp b/app/src/main/cpp/jni_bridge.cpp index 6b04cb9..25e40b1 100644 --- a/app/src/main/cpp/jni_bridge.cpp +++ b/app/src/main/cpp/jni_bridge.cpp @@ -4,8 +4,16 @@ #include +#include "core_identity.h" +#include "core_session.h" #include "native_smoke.h" +namespace neslite { +void renderer_created(); +void renderer_changed(int width, int height); +void renderer_draw(bool integer_scale); +} + extern "C" JNIEXPORT jstring JNICALL Java_org_neslite_app_NativeBridge_buildInfo(JNIEnv* env, jclass) { const std::string info = "native protocol v" + std::to_string(neslite::native_protocol_version()); @@ -17,3 +25,58 @@ Java_org_neslite_app_NativeBridge_pageSizeBytes(JNIEnv*, jclass) { const long page_size = sysconf(_SC_PAGESIZE); return page_size > 0 ? static_cast(page_size) : 0; } + +extern "C" JNIEXPORT jstring JNICALL +Java_org_neslite_app_NativeBridge_coreInfo(JNIEnv* env, jclass) { + const std::string info = neslite::core_identity(); + return env->NewStringUTF(info.c_str()); +} + +namespace { +std::string from_jstring(JNIEnv* env, jstring value) { + if (value == nullptr) return {}; + const char* utf = env->GetStringUTFChars(value, nullptr); + if (utf == nullptr) return {}; + std::string result(utf); + env->ReleaseStringUTFChars(value, utf); + return result; +} +} + +extern "C" JNIEXPORT jlong JNICALL +Java_org_neslite_app_NativeBridge_loadRom(JNIEnv* env, jclass, jstring path, jstring system_dir, + jstring save_dir, jstring hash) { + return static_cast(neslite::load_rom(from_jstring(env, path), from_jstring(env, system_dir), + from_jstring(env, save_dir), from_jstring(env, hash))); +} + +extern "C" JNIEXPORT jboolean JNICALL +Java_org_neslite_app_NativeBridge_command(JNIEnv* env, jclass, jlong session_id, jstring command) { + return neslite::session_command(static_cast(session_id), from_jstring(env, command)); +} + +extern "C" JNIEXPORT void JNICALL +Java_org_neslite_app_NativeBridge_setJoypadMask(JNIEnv*, jclass, jint mask) { + neslite::set_joypad_mask(static_cast(mask)); +} + +extern "C" JNIEXPORT jstring JNICALL +Java_org_neslite_app_NativeBridge_sessionStatus(JNIEnv* env, jclass) { + const std::string status = neslite::session_status_json(); + return env->NewStringUTF(status.c_str()); +} + +extern "C" JNIEXPORT void JNICALL +Java_org_neslite_app_NativeBridge_rendererCreated(JNIEnv*, jclass) { + neslite::renderer_created(); +} + +extern "C" JNIEXPORT void JNICALL +Java_org_neslite_app_NativeBridge_rendererChanged(JNIEnv*, jclass, jint width, jint height) { + neslite::renderer_changed(width, height); +} + +extern "C" JNIEXPORT void JNICALL +Java_org_neslite_app_NativeBridge_rendererDraw(JNIEnv*, jclass, jboolean integer_scale) { + neslite::renderer_draw(integer_scale); +} diff --git a/app/src/main/cpp/session_rules.cpp b/app/src/main/cpp/session_rules.cpp new file mode 100644 index 0000000..07a7d5b --- /dev/null +++ b/app/src/main/cpp/session_rules.cpp @@ -0,0 +1,37 @@ +#include "session_rules.h" + +namespace neslite { + +const char* session_state_name(SessionState state) { + switch (state) { + case SessionState::Idle: return "Idle"; + case SessionState::Loading: return "Loading"; + case SessionState::Paused: return "Paused"; + case SessionState::Running: return "Running"; + case SessionState::Pausing: return "Pausing"; + case SessionState::Stopping: return "Stopping"; + case SessionState::Error: return "Error"; + } + return "Error"; +} + +bool command_allowed(SessionState state, std::string_view command) { + if (command == "load") return state != SessionState::Loading && state != SessionState::Stopping; + if (command == "run") return state == SessionState::Paused; + if (command == "pause") return state == SessionState::Running; + if (command == "reset") return state == SessionState::Paused || state == SessionState::Running; + if (command == "stop") return state == SessionState::Paused || state == SessionState::Running || + state == SessionState::Error; + return false; +} + +bool command_targets_active_session(std::uint64_t active_session, std::uint64_t command_session) { + return active_session != 0 && active_session == command_session; +} + +bool required_host_capabilities_available(unsigned core_api_version, unsigned expected_api_version, + bool directories_available) { + return core_api_version == expected_api_version && directories_available; +} + +} // namespace neslite diff --git a/app/src/main/cpp/session_rules.h b/app/src/main/cpp/session_rules.h new file mode 100644 index 0000000..f287aba --- /dev/null +++ b/app/src/main/cpp/session_rules.h @@ -0,0 +1,16 @@ +#pragma once + +#include +#include + +namespace neslite { + +enum class SessionState { Idle, Loading, Paused, Running, Pausing, Stopping, Error }; + +const char* session_state_name(SessionState state); +bool command_allowed(SessionState state, std::string_view command); +bool command_targets_active_session(std::uint64_t active_session, std::uint64_t command_session); +bool required_host_capabilities_available(unsigned core_api_version, unsigned expected_api_version, + bool directories_available); + +} // namespace neslite diff --git a/app/src/main/cpp/tests/native_smoke_test.cpp b/app/src/main/cpp/tests/native_smoke_test.cpp index 9e9669e..3c3db06 100644 --- a/app/src/main/cpp/tests/native_smoke_test.cpp +++ b/app/src/main/cpp/tests/native_smoke_test.cpp @@ -1,5 +1,31 @@ #include "native_smoke.h" +#include "session_rules.h" +#include "video_buffer.h" int main() { - return neslite::native_protocol_version() == neslite::kNativeProtocolVersion ? 0 : 1; + using neslite::SessionState; + if (neslite::native_protocol_version() != neslite::kNativeProtocolVersion) return 1; + if (!neslite::command_allowed(SessionState::Paused, "run")) return 2; + if (neslite::command_allowed(SessionState::Running, "run")) return 3; + if (!neslite::command_allowed(SessionState::Running, "pause")) return 4; + if (neslite::command_allowed(SessionState::Loading, "reset")) return 5; + if (!neslite::command_targets_active_session(9, 9)) return 6; + if (neslite::command_targets_active_session(10, 9)) return 7; + if (neslite::command_targets_active_session(0, 0)) return 8; + if (!neslite::required_host_capabilities_available(1, 1, true)) return 16; + if (neslite::required_host_capabilities_available(2, 1, true)) return 17; + if (neslite::required_host_capabilities_available(1, 1, false)) return 18; + neslite::VideoBuffer video; + const unsigned char padded[] = {1, 2, 3, 4, 99, 99, 5, 6, 7, 8, 99, 99}; + if (!video.submit(padded, 2, 2, 6, 2, 2)) return 9; + neslite::VideoFrame frame; + if (!video.latest(&frame) || frame.pitch != 4 || frame.bytes.size() != 8) return 10; + if (static_cast(frame.bytes[4]) != 5) return 11; + const auto first_sequence = frame.sequence; + if (video.submit(nullptr, 2, 2, 4, 2, 2)) return 12; + if (!video.latest(&frame) || frame.sequence != first_sequence) return 13; + const unsigned char replacement[] = {9, 10, 11, 12}; + if (!video.submit(replacement, 2, 1, 4, 2, 2)) return 14; + if (!video.latest(&frame) || frame.sequence != first_sequence + 1 || frame.height != 1) return 15; + return 0; } diff --git a/app/src/main/cpp/video_buffer.cpp b/app/src/main/cpp/video_buffer.cpp new file mode 100644 index 0000000..7736462 --- /dev/null +++ b/app/src/main/cpp/video_buffer.cpp @@ -0,0 +1,36 @@ +#include "video_buffer.h" + +#include + +namespace neslite { + +bool VideoBuffer::submit(const void* data, unsigned width, unsigned height, std::size_t source_pitch, + unsigned bytes_per_pixel, int pixel_format) { + if (data == nullptr) return false; // Duplicate-frame marker retains the previous frame. + const std::size_t row_bytes = static_cast(width) * bytes_per_pixel; + if (width == 0 || height == 0 || bytes_per_pixel == 0 || source_pitch < row_bytes) return false; + VideoFrame next; + next.width = width; + next.height = height; + next.pitch = static_cast(row_bytes); + next.pixel_format = pixel_format; + next.bytes.resize(row_bytes * height); + const auto* source = static_cast(data); + for (unsigned row = 0; row < height; ++row) { + std::copy_n(source + row * source_pitch, row_bytes, next.bytes.data() + row * row_bytes); + } + std::lock_guard lock(mutex_); + next.sequence = frame_.sequence + 1; + frame_ = std::move(next); + return true; +} + +bool VideoBuffer::latest(VideoFrame* frame) const { + if (frame == nullptr) return false; + std::lock_guard lock(mutex_); + if (frame_.sequence == 0) return false; + *frame = frame_; + return true; +} + +} // namespace neslite diff --git a/app/src/main/cpp/video_buffer.h b/app/src/main/cpp/video_buffer.h new file mode 100644 index 0000000..0cc3844 --- /dev/null +++ b/app/src/main/cpp/video_buffer.h @@ -0,0 +1,30 @@ +#pragma once + +#include +#include +#include +#include + +namespace neslite { + +struct VideoFrame { + unsigned width = 0; + unsigned height = 0; + unsigned pitch = 0; + int pixel_format = 0; + std::uint64_t sequence = 0; + std::string bytes; +}; + +class VideoBuffer { + public: + bool submit(const void* data, unsigned width, unsigned height, std::size_t source_pitch, + unsigned bytes_per_pixel, int pixel_format); + bool latest(VideoFrame* frame) const; + + private: + mutable std::mutex mutex_; + VideoFrame frame_; +}; + +} // namespace neslite diff --git a/app/src/main/java/org/neslite/app/EmulatorSurface.kt b/app/src/main/java/org/neslite/app/EmulatorSurface.kt new file mode 100644 index 0000000..b935fa7 --- /dev/null +++ b/app/src/main/java/org/neslite/app/EmulatorSurface.kt @@ -0,0 +1,25 @@ +package org.neslite.app + +import android.content.Context +import android.opengl.GLSurfaceView +import javax.microedition.khronos.egl.EGLConfig +import javax.microedition.khronos.opengles.GL10 + +class EmulatorSurface(context: Context) : GLSurfaceView(context), GLSurfaceView.Renderer { + @Volatile + var integerScale: Boolean = false + + init { + setEGLContextClientVersion(2) + setRenderer(this) + renderMode = RENDERMODE_CONTINUOUSLY + preserveEGLContextOnPause = true + } + + override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) = NativeBridge.rendererCreated() + + override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) = + NativeBridge.rendererChanged(width, height) + + override fun onDrawFrame(gl: GL10?) = NativeBridge.rendererDraw(integerScale) +} diff --git a/app/src/main/java/org/neslite/app/MainActivity.kt b/app/src/main/java/org/neslite/app/MainActivity.kt index b61376b..120393e 100644 --- a/app/src/main/java/org/neslite/app/MainActivity.kt +++ b/app/src/main/java/org/neslite/app/MainActivity.kt @@ -4,6 +4,8 @@ import android.content.Context import android.hardware.input.InputManager import android.net.Uri import android.os.Bundle +import android.os.Handler +import android.os.Looper import android.os.SystemClock import android.text.method.ScrollingMovementMethod import android.view.InputDevice @@ -24,9 +26,15 @@ import org.neslite.app.diagnostics.DeviceBaseline import org.neslite.app.diagnostics.DeviceDiagnostics import org.neslite.app.diagnostics.DiagnosticEventJson import org.neslite.app.diagnostics.InputDiagnostics +import org.neslite.app.library.GameDatabase +import org.neslite.app.library.GameEntity +import org.neslite.app.library.LibraryRecovery +import org.neslite.app.library.RomImporter +import java.io.File import java.text.SimpleDateFormat import java.util.Date import java.util.Locale +import java.util.concurrent.Executors class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private val inputDiagnostics = InputDiagnostics() @@ -38,6 +46,14 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private lateinit var stateText: TextView private lateinit var eventText: TextView private var controllers: List = emptyList() + private val libraryExecutor = Executors.newSingleThreadExecutor() + private val mainHandler = Handler(Looper.getMainLooper()) + private lateinit var database: GameDatabase + private lateinit var gameList: LinearLayout + private lateinit var emulatorSurface: EmulatorSurface + private lateinit var emulatorStatus: TextView + private var activeSessionId = 0L + private var joypadMask = 0 private val createDocument = registerForActivityResult( ActivityResultContracts.CreateDocument("application/json"), @@ -45,30 +61,57 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { if (uri != null) exportDiagnostics(uri) } + private val openRom = registerForActivityResult(ActivityResultContracts.OpenDocument()) { uri -> + if (uri != null) importRom(uri) + } + override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) inputManager = getSystemService(Context.INPUT_SERVICE) as InputManager nativeProbe = probeNative() baseline = DeviceDiagnostics.collectBaseline(this, nativeProbe.pageSizeBytes) + database = GameDatabase.get(this) + activeSessionId = savedInstanceState?.getLong(STATE_SESSION_ID) ?: 0L setContentView(createContentView()) refreshControllers() + recoverLibrary() + pollSessionStatus() } override fun onStart() { super.onStart() inputManager.registerInputDeviceListener(this, null) refreshControllers() + if (::emulatorSurface.isInitialized) emulatorSurface.onResume() } override fun onStop() { + if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") + NativeBridge.setJoypadMask(0) + joypadMask = 0 + if (::emulatorSurface.isInitialized) emulatorSurface.onPause() inputDiagnostics.clearAll("activity_stopped", SystemClock.uptimeMillis()) inputManager.unregisterInputDeviceListener(this) super.onStop() } + override fun onDestroy() { + mainHandler.removeCallbacksAndMessages(null) + libraryExecutor.shutdownNow() + super.onDestroy() + } + + override fun onSaveInstanceState(outState: Bundle) { + outState.putLong(STATE_SESSION_ID, activeSessionId) + super.onSaveInstanceState(outState) + } + override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus) if (!hasFocus && ::stateText.isInitialized) { + NativeBridge.setJoypadMask(0) + joypadMask = 0 + if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") inputDiagnostics.clearAll("focus_lost", SystemClock.uptimeMillis()) renderInputState() } @@ -86,6 +129,9 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { } override fun onInputDeviceRemoved(deviceId: Int) { + NativeBridge.setJoypadMask(0) + joypadMask = 0 + if (activeSessionId != 0L) NativeBridge.command(activeSessionId, "pause") inputDiagnostics.clearDevice( deviceId, "device_removed", @@ -111,6 +157,14 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { keyName = KeyEvent.keyCodeToString(event.keyCode), repeatCount = event.repeatCount, ) + joypadBitForKey(event.keyCode)?.let { bit -> + joypadMask = if (event.action == KeyEvent.ACTION_UP) { + joypadMask and (1 shl bit).inv() + } else { + joypadMask or (1 shl bit) + } + NativeBridge.setJoypadMask(joypadMask) + } renderInputState() return true } @@ -132,6 +186,12 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { value = event.getAxisValue(range.axis), ) } + joypadMask = joypadMask + .withBit(6, event.getAxisValue(MotionEvent.AXIS_X) < -0.5f || event.getAxisValue(MotionEvent.AXIS_HAT_X) < -0.5f) + .withBit(7, event.getAxisValue(MotionEvent.AXIS_X) > 0.5f || event.getAxisValue(MotionEvent.AXIS_HAT_X) > 0.5f) + .withBit(4, event.getAxisValue(MotionEvent.AXIS_Y) < -0.5f || event.getAxisValue(MotionEvent.AXIS_HAT_Y) < -0.5f) + .withBit(5, event.getAxisValue(MotionEvent.AXIS_Y) > 0.5f || event.getAxisValue(MotionEvent.AXIS_HAT_Y) > 0.5f) + NativeBridge.setJoypadMask(joypadMask) renderInputState() return true } @@ -150,6 +210,49 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { setPadding(32, 32, 32, 48) addView(title(getString(R.string.diagnostics_title))) addView(body(getString(R.string.diagnostics_instructions))) + addView(section("M2 游戏库与基础运行")) + addView( + Button(context).apply { + text = "从文件导入 iNES / NES 2.0 ROM" + setOnClickListener { openRom.launch(arrayOf("application/octet-stream", "*/*")) } + }, + ) + gameList = LinearLayout(context).apply { orientation = LinearLayout.VERTICAL } + addView(gameList) + emulatorSurface = EmulatorSurface(context) + addView( + emulatorSurface, + LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 720), + ) + emulatorStatus = body("状态:Idle") + addView(emulatorStatus) + addView( + LinearLayout(context).apply { + orientation = LinearLayout.HORIZONTAL + listOf( + "运行" to "run", + "暂停" to "pause", + "重置" to "reset", + "退出" to "stop", + ).forEach { (label, command) -> + addView(Button(context).apply { + text = label + setOnClickListener { + if (activeSessionId != 0L) NativeBridge.command(activeSessionId, command) + } + }) + } + }, + ) + addView( + Button(context).apply { + text = "缩放:4:3(点按切换整数像素)" + setOnClickListener { + emulatorSurface.integerScale = !emulatorSurface.integerScale + text = if (emulatorSurface.integerScale) "缩放:整数像素" else "缩放:4:3" + } + }, + ) addView(section(getString(R.string.section_native))) addView(body(nativeProbe.render())) addView(section(getString(R.string.section_device))) @@ -256,6 +359,91 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { } } + private fun importRom(uri: Uri) { + emulatorStatus.text = "正在流式导入…" + libraryExecutor.execute { + runCatching { RomImporter(contentResolver, filesDir, database.games()).import(uri) } + .onSuccess { result -> + runOnUiThread { + Toast.makeText( + this, + if (result.duplicate) "内容已存在,已复用原文件" else "导入完成", + Toast.LENGTH_LONG, + ).show() + emulatorStatus.text = "导入完成:${result.game.displayName}" + refreshLibrary() + } + } + .onFailure { error -> + runOnUiThread { + emulatorStatus.text = "导入失败:${error.message ?: error.javaClass.simpleName}" + } + } + } + } + + private fun recoverLibrary() { + libraryExecutor.execute { + val report = LibraryRecovery(filesDir, database.games()).reconcile() + runOnUiThread { + if (report.removedTemps + report.recoveredFiles + report.missingRows > 0) { + emulatorStatus.text = "恢复检查:临时 ${report.removedTemps},恢复 ${report.recoveredFiles},缺失 ${report.missingRows}" + } + refreshLibrary() + } + } + } + + private fun refreshLibrary() { + libraryExecutor.execute { + val games = database.games().all() + runOnUiThread { + gameList.removeAllViews() + if (games.isEmpty()) gameList.addView(body("尚未导入 ROM")) + games.forEach { game -> + gameList.addView(Button(this).apply { + text = "${game.displayName} · ${game.format} · ${game.sha256.take(8)} · ${game.status}" + isEnabled = game.status == GameEntity.STATUS_READY + setOnClickListener { loadGame(game) } + }) + } + } + } + } + + private fun loadGame(game: GameEntity) { + val path = File(File(filesDir, "roms"), game.fileName).absolutePath + activeSessionId = NativeBridge.loadRom( + path, + File(filesDir, "system").apply { mkdirs() }.absolutePath, + File(filesDir, "saves").apply { mkdirs() }.absolutePath, + game.sha256, + ) + emulatorStatus.text = if (activeSessionId == 0L) "命令队列已满" else "正在加载会话 $activeSessionId" + } + + private fun pollSessionStatus() { + if (::emulatorStatus.isInitialized && activeSessionId != 0L) { + emulatorStatus.text = NativeBridge.sessionStatus() + } + mainHandler.postDelayed(::pollSessionStatus, 250) + } + + private fun joypadBitForKey(keyCode: Int): Int? = when (keyCode) { + KeyEvent.KEYCODE_DPAD_UP -> 4 + KeyEvent.KEYCODE_DPAD_DOWN -> 5 + KeyEvent.KEYCODE_DPAD_LEFT -> 6 + KeyEvent.KEYCODE_DPAD_RIGHT -> 7 + KeyEvent.KEYCODE_BUTTON_A -> 8 + KeyEvent.KEYCODE_BUTTON_B -> 0 + KeyEvent.KEYCODE_BUTTON_START -> 3 + KeyEvent.KEYCODE_BUTTON_SELECT -> 2 + else -> null + } + + private fun Int.withBit(bit: Int, enabled: Boolean): Int = + if (enabled) this or (1 shl bit) else this and (1 shl bit).inv() + private fun buildDiagnosticReport(): JSONObject = JSONObject() .put("formatVersion", 1) .put("exportedAtEpochMs", System.currentTimeMillis()) @@ -272,6 +460,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { JSONObject() .put("loaded", nativeProbe.loaded) .put("buildInfo", nativeProbe.buildInfo ?: JSONObject.NULL) + .put("coreInfo", nativeProbe.coreInfo ?: JSONObject.NULL) .put("pageSizeBytes", nativeProbe.pageSizeBytes ?: JSONObject.NULL) .put("error", nativeProbe.error ?: JSONObject.NULL), ) @@ -284,6 +473,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { NativeProbe( loaded = true, buildInfo = NativeBridge.buildInfo(), + coreInfo = NativeBridge.coreInfo(), pageSizeBytes = NativeBridge.pageSizeBytes(), error = null, ) @@ -291,6 +481,7 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { NativeProbe( loaded = false, buildInfo = null, + coreInfo = null, pageSizeBytes = null, error = "${error.javaClass.name}: ${error.message ?: "无详细消息"}", ) @@ -323,11 +514,12 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { private data class NativeProbe( val loaded: Boolean, val buildInfo: String?, + val coreInfo: String?, val pageSizeBytes: Long?, val error: String?, ) { fun render(): String = if (loaded) { - "状态:成功\n入口:$buildInfo\n页大小:${pageSizeBytes ?: "未知"} bytes" + "状态:成功\n入口:$buildInfo\n内核:$coreInfo\n页大小:${pageSizeBytes ?: "未知"} bytes" } else { "状态:失败\n错误:$error" } @@ -347,5 +539,6 @@ class MainActivity : ComponentActivity(), InputManager.InputDeviceListener { companion object { private const val EVENT_LINES = 30 + private const val STATE_SESSION_ID = "active_session_id" } } diff --git a/app/src/main/java/org/neslite/app/NativeBridge.kt b/app/src/main/java/org/neslite/app/NativeBridge.kt index 063f2dd..77e8f01 100644 --- a/app/src/main/java/org/neslite/app/NativeBridge.kt +++ b/app/src/main/java/org/neslite/app/NativeBridge.kt @@ -9,4 +9,20 @@ object NativeBridge { external fun buildInfo(): String external fun pageSizeBytes(): Long + + external fun coreInfo(): String + + external fun loadRom(path: String, systemDir: String, saveDir: String, romHash: String): Long + + external fun command(sessionId: Long, command: String): Boolean + + external fun setJoypadMask(mask: Int) + + external fun sessionStatus(): String + + external fun rendererCreated() + + external fun rendererChanged(width: Int, height: Int) + + external fun rendererDraw(integerScale: Boolean) } diff --git a/app/src/main/java/org/neslite/app/library/GameDao.java b/app/src/main/java/org/neslite/app/library/GameDao.java new file mode 100644 index 0000000..9286aa7 --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/GameDao.java @@ -0,0 +1,22 @@ +package org.neslite.app.library; + +import androidx.room.Dao; +import androidx.room.Insert; +import androidx.room.OnConflictStrategy; +import androidx.room.Query; +import java.util.List; + +@Dao +public interface GameDao { + @Query("SELECT * FROM games ORDER BY displayName COLLATE NOCASE, sha256") + List all(); + + @Query("SELECT * FROM games WHERE sha256 = :sha256 LIMIT 1") + GameEntity byHash(String sha256); + + @Insert(onConflict = OnConflictStrategy.IGNORE) + long insert(GameEntity game); + + @Query("UPDATE games SET status = :status WHERE sha256 = :sha256") + void setStatus(String sha256, String status); +} diff --git a/app/src/main/java/org/neslite/app/library/GameDatabase.java b/app/src/main/java/org/neslite/app/library/GameDatabase.java new file mode 100644 index 0000000..43e38bc --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/GameDatabase.java @@ -0,0 +1,29 @@ +package org.neslite.app.library; + +import android.content.Context; +import androidx.room.Database; +import androidx.room.Room; +import androidx.room.RoomDatabase; + +@Database(entities = {GameEntity.class}, version = 1, exportSchema = false) +public abstract class GameDatabase extends RoomDatabase { + private static volatile GameDatabase instance; + + public abstract GameDao games(); + + public static GameDatabase get(Context context) { + GameDatabase current = instance; + if (current != null) return current; + synchronized (GameDatabase.class) { + current = instance; + if (current == null) { + current = Room.databaseBuilder( + context.getApplicationContext(), + GameDatabase.class, + "neslite-games.db").build(); + instance = current; + } + } + return current; + } +} diff --git a/app/src/main/java/org/neslite/app/library/GameEntity.java b/app/src/main/java/org/neslite/app/library/GameEntity.java new file mode 100644 index 0000000..ae70609 --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/GameEntity.java @@ -0,0 +1,36 @@ +package org.neslite.app.library; + +import androidx.annotation.NonNull; +import androidx.room.Entity; +import androidx.room.PrimaryKey; + +@Entity(tableName = "games") +public final class GameEntity { + public static final String STATUS_READY = "READY"; + public static final String STATUS_MISSING = "MISSING"; + + @PrimaryKey @NonNull public final String sha256; + @NonNull public final String displayName; + public final long sizeBytes; + @NonNull public final String format; + @NonNull public final String fileName; + @NonNull public final String status; + public final long addedAtEpochMs; + + public GameEntity( + @NonNull String sha256, + @NonNull String displayName, + long sizeBytes, + @NonNull String format, + @NonNull String fileName, + @NonNull String status, + long addedAtEpochMs) { + this.sha256 = sha256; + this.displayName = displayName; + this.sizeBytes = sizeBytes; + this.format = format; + this.fileName = fileName; + this.status = status; + this.addedAtEpochMs = addedAtEpochMs; + } +} diff --git a/app/src/main/java/org/neslite/app/library/LibraryRecovery.kt b/app/src/main/java/org/neslite/app/library/LibraryRecovery.kt new file mode 100644 index 0000000..d6b6f04 --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/LibraryRecovery.kt @@ -0,0 +1,66 @@ +package org.neslite.app.library + +import java.io.File +import java.io.FileInputStream +import java.security.MessageDigest + +class LibraryRecovery(filesDir: File, private val dao: GameDao) { + private val romDir = File(filesDir, "roms") + + data class Report(val removedTemps: Int, val recoveredFiles: Int, val missingRows: Int) + + fun reconcile(): Report { + romDir.mkdirs() + var removedTemps = 0 + romDir.listFiles { file -> file.name.startsWith(".import-") && file.name.endsWith(".tmp") } + .orEmpty().forEach { if (it.delete()) removedTemps++ } + + var recoveredFiles = 0 + romDir.listFiles { file -> file.isFile && file.extension.equals("nes", ignoreCase = true) } + .orEmpty().forEach { file -> + val hash = sha256(file) + if (hash != file.nameWithoutExtension || dao.byHash(hash) != null) return@forEach + val header = runCatching { + FileInputStream(file).use { input -> + val bytes = ByteArray(NesHeaderParser.HEADER_SIZE) + val count = input.read(bytes) + NesHeaderParser.parse(bytes.copyOf(maxOf(0, count))) + } + }.getOrNull() ?: return@forEach + dao.insert( + GameEntity( + hash, + "已恢复 ${hash.take(8)}.nes", + file.length(), + header.format, + file.name, + GameEntity.STATUS_READY, + System.currentTimeMillis(), + ), + ) + recoveredFiles++ + } + + var missingRows = 0 + dao.all().forEach { game -> + val exists = File(romDir, game.fileName).isFile + val next = if (exists) GameEntity.STATUS_READY else GameEntity.STATUS_MISSING + if (game.status != next) dao.setStatus(game.sha256, next) + if (!exists) missingRows++ + } + return Report(removedTemps, recoveredFiles, missingRows) + } + + private fun sha256(file: File): String { + val digest = MessageDigest.getInstance("SHA-256") + FileInputStream(file).use { input -> + val buffer = ByteArray(DEFAULT_BUFFER_SIZE) + while (true) { + val count = input.read(buffer) + if (count < 0) break + digest.update(buffer, 0, count) + } + } + return digest.digest().joinToString("") { "%02x".format(it) } + } +} diff --git a/app/src/main/java/org/neslite/app/library/NesHeader.kt b/app/src/main/java/org/neslite/app/library/NesHeader.kt new file mode 100644 index 0000000..bec3e46 --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/NesHeader.kt @@ -0,0 +1,21 @@ +package org.neslite.app.library + +data class NesHeader(val format: String, val hasBattery: Boolean) + +object NesHeaderParser { + const val HEADER_SIZE = 16 + + fun parse(header: ByteArray): NesHeader { + require(header.size >= HEADER_SIZE) { "文件短于 16 字节 NES 头" } + require(header[0] == 'N'.code.toByte() && header[1] == 'E'.code.toByte() && + header[2] == 'S'.code.toByte() && header[3] == 0x1A.toByte()) { + "不是 iNES/NES 2.0 文件" + } + val flags7 = header[7].toInt() and 0xFF + val isNes2 = flags7 and 0x0C == 0x08 + return NesHeader( + format = if (isNes2) "NES 2.0" else "iNES", + hasBattery = header[6].toInt() and 0x02 != 0, + ) + } +} diff --git a/app/src/main/java/org/neslite/app/library/RomImporter.kt b/app/src/main/java/org/neslite/app/library/RomImporter.kt new file mode 100644 index 0000000..df5f84b --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/RomImporter.kt @@ -0,0 +1,78 @@ +package org.neslite.app.library + +import android.content.ContentResolver +import android.net.Uri +import android.provider.OpenableColumns +import java.io.File +import java.util.UUID + +class RomImporter( + private val resolver: ContentResolver, + filesDir: File, + private val dao: GameDao, +) { + private val romDir = File(filesDir, "roms") + + data class Result(val game: GameEntity, val duplicate: Boolean) + + fun import(uri: Uri): Result { + romDir.mkdirs() + val temp = File(romDir, ".import-${UUID.randomUUID()}.tmp") + try { + val copied = resolver.openInputStream(uri).use { input -> + requireNotNull(input) { "系统未提供可读输入流" } + RomStreamCopier.copy(input, temp) + } + val header = copied.header + val hash = copied.sha256 + val finalFile = File(romDir, "$hash.nes") + dao.byHash(hash)?.let { existing -> + if (!finalFile.isFile) { + require(temp.renameTo(finalFile)) { "无法恢复缺失的内部 ROM 文件" } + dao.setStatus(hash, GameEntity.STATUS_READY) + return Result( + GameEntity( + existing.sha256, + existing.displayName, + copied.sizeBytes, + header.format, + finalFile.name, + GameEntity.STATUS_READY, + existing.addedAtEpochMs, + ), + duplicate = true, + ) + } + temp.delete() + return Result(existing, duplicate = true) + } + if (!finalFile.exists()) require(temp.renameTo(finalFile)) { "无法提交内部 ROM 文件" } + else temp.delete() + val game = GameEntity( + hash, + displayName(uri), + copied.sizeBytes, + header.format, + finalFile.name, + GameEntity.STATUS_READY, + System.currentTimeMillis(), + ) + dao.insert(game) + return Result(dao.byHash(hash) ?: game, duplicate = false) + } catch (error: Throwable) { + temp.delete() + throw error + } + } + + private fun displayName(uri: Uri): String { + resolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)?.use { cursor -> + if (cursor.moveToFirst()) return cursor.getString(0)?.takeIf(String::isNotBlank) ?: "未命名 ROM" + } + return uri.lastPathSegment?.substringAfterLast('/')?.takeIf(String::isNotBlank) ?: "未命名 ROM" + } + + companion object { + const val MAX_ROM_BYTES = 64L * 1024L * 1024L + } +} diff --git a/app/src/main/java/org/neslite/app/library/RomStreamCopier.kt b/app/src/main/java/org/neslite/app/library/RomStreamCopier.kt new file mode 100644 index 0000000..36d3e27 --- /dev/null +++ b/app/src/main/java/org/neslite/app/library/RomStreamCopier.kt @@ -0,0 +1,45 @@ +package org.neslite.app.library + +import java.io.File +import java.io.FileOutputStream +import java.io.InputStream +import java.security.MessageDigest + +object RomStreamCopier { + data class CopyResult(val sha256: String, val sizeBytes: Long, val header: NesHeader) + + fun copy(input: InputStream, temp: File, maxBytes: Long = RomImporter.MAX_ROM_BYTES): CopyResult { + try { + val digest = MessageDigest.getInstance("SHA-256") + val headerBytes = ByteArray(NesHeaderParser.HEADER_SIZE) + var headerCount = 0 + var total = 0L + FileOutputStream(temp).use { output -> + val buffer = ByteArray(DEFAULT_BUFFER_SIZE) + while (true) { + if (Thread.currentThread().isInterrupted) throw InterruptedException("导入已取消") + val count = input.read(buffer) + if (count < 0) break + total += count + require(total <= maxBytes) { "ROM 超过 64 MiB 上限" } + if (headerCount < headerBytes.size) { + val copied = minOf(count, headerBytes.size - headerCount) + buffer.copyInto(headerBytes, headerCount, 0, copied) + headerCount += copied + } + digest.update(buffer, 0, count) + output.write(buffer, 0, count) + } + output.fd.sync() + } + return CopyResult( + sha256 = digest.digest().joinToString("") { "%02x".format(it) }, + sizeBytes = total, + header = NesHeaderParser.parse(headerBytes.copyOf(headerCount)), + ) + } catch (error: Throwable) { + temp.delete() + throw error + } + } +} diff --git a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt index ccfe004..c79f63a 100644 --- a/app/src/test/java/org/neslite/app/BuildIdentityTest.kt +++ b/app/src/test/java/org/neslite/app/BuildIdentityTest.kt @@ -7,7 +7,7 @@ class BuildIdentityTest { @Test fun debugBuildUsesTheDocumentedIdentity() { assertEquals("org.neslite.app.debug", BuildConfig.APPLICATION_ID) - assertEquals("0.1.3-debug", BuildConfig.VERSION_NAME) - assertEquals(1003, BuildConfig.VERSION_CODE) + assertEquals("0.2.4-debug", BuildConfig.VERSION_NAME) + assertEquals(2004, BuildConfig.VERSION_CODE) } } diff --git a/app/src/test/java/org/neslite/app/library/NesHeaderTest.kt b/app/src/test/java/org/neslite/app/library/NesHeaderTest.kt new file mode 100644 index 0000000..e2124fb --- /dev/null +++ b/app/src/test/java/org/neslite/app/library/NesHeaderTest.kt @@ -0,0 +1,38 @@ +package org.neslite.app.library + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class NesHeaderTest { + @Test fun parsesINesAndBatteryFlag() { + val bytes = ByteArray(16).apply { + this[0] = 'N'.code.toByte(); this[1] = 'E'.code.toByte(); this[2] = 'S'.code.toByte(); this[3] = 0x1A + this[6] = 0x02 + } + val header = NesHeaderParser.parse(bytes) + assertEquals("iNES", header.format) + assertTrue(header.hasBattery) + } + + @Test fun parsesNes20() { + val bytes = ByteArray(16).apply { + this[0] = 'N'.code.toByte(); this[1] = 'E'.code.toByte(); this[2] = 'S'.code.toByte(); this[3] = 0x1A + this[7] = 0x08 + } + val header = NesHeaderParser.parse(bytes) + assertEquals("NES 2.0", header.format) + assertFalse(header.hasBattery) + } + + @Test(expected = IllegalArgumentException::class) + fun rejectsDamagedHeader() { + NesHeaderParser.parse(ByteArray(16)) + } + + @Test(expected = IllegalArgumentException::class) + fun rejectsShortFile() { + NesHeaderParser.parse(byteArrayOf(1, 2, 3)) + } +} diff --git a/app/src/test/java/org/neslite/app/library/RomStreamCopierTest.kt b/app/src/test/java/org/neslite/app/library/RomStreamCopierTest.kt new file mode 100644 index 0000000..83955e7 --- /dev/null +++ b/app/src/test/java/org/neslite/app/library/RomStreamCopierTest.kt @@ -0,0 +1,45 @@ +package org.neslite.app.library + +import java.io.ByteArrayInputStream +import java.nio.file.Files +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class RomStreamCopierTest { + @Test fun copiesValidRomAndComputesFullHash() { + val rom = validRom() + byteArrayOf(1, 2, 3, 4) + val temp = Files.createTempFile("neslite", ".tmp").toFile().apply { delete() } + try { + val result = RomStreamCopier.copy(ByteArrayInputStream(rom), temp, 1024) + assertEquals(rom.size.toLong(), result.sizeBytes) + assertEquals("iNES", result.header.format) + assertEquals(64, result.sha256.length) + assertTrue(temp.readBytes().contentEquals(rom)) + } finally { + temp.delete() + } + } + + @Test fun rejectsOversizeAndCleansTemp() { + val temp = Files.createTempFile("neslite", ".tmp").toFile().apply { delete() } + runCatching { RomStreamCopier.copy(ByteArrayInputStream(validRom()), temp, 8) } + .onSuccess { throw AssertionError("oversize input should fail") } + assertFalse(temp.exists()) + } + + @Test fun rejectsDamagedInputAndCleansTemp() { + val temp = Files.createTempFile("neslite", ".tmp").toFile().apply { delete() } + runCatching { RomStreamCopier.copy(ByteArrayInputStream(ByteArray(16)), temp, 1024) } + .onSuccess { throw AssertionError("damaged input should fail") } + assertFalse(temp.exists()) + } + + private fun validRom(): ByteArray = ByteArray(16).apply { + this[0] = 'N'.code.toByte() + this[1] = 'E'.code.toByte() + this[2] = 'S'.code.toByte() + this[3] = 0x1A + } +} diff --git a/docs/architecture.md b/docs/architecture.md new file mode 100644 index 0000000..0b201da --- /dev/null +++ b/docs/architecture.md @@ -0,0 +1,54 @@ +# NESLite 架构(M2 基线) + +## 边界与线程 + +界面层只负责系统文件选择器、游戏列表、控制按钮、手柄事件和 GL Surface。ROM 的 `content://` +地址只在 Kotlin 导入层使用;导入完成后,原生层仅收到应用私有目录中的绝对文件路径。 + +FCEUmm 由一个原生工作线程独占。JNI 调用只向容量 32 的命令队列写入 `load/run/pause/reset/stop` +命令,命令携带单调递增的会话号。旧会话、重复命令和当前状态不允许的命令不会触碰内核,并在 +状态快照的完成通知中报告 `stale` 或 `ignored`。状态集合固定为 Idle、Loading、Paused、 +Running、Pausing、Stopping 和 Error。 + +## ROM 和索引 + +系统文件选择器的输入流先写入 `files/roms/.import-.tmp`。导入过程限制为 64 MiB,校验 +iNES/NES 2.0 魔数并计算完整文件 SHA-256;提交文件为 `files/roms/.nes`。Room 以哈希 +作为主键,因此相同内容去重、同名不同内容分别登记。写文件后、写数据库前中断留下的有效正式 +文件会在下次启动恢复为索引项;残留导入临时文件会清除;索引缺少文件时标记为 `MISSING`,重新 +导入相同内容可恢复文件和状态。 + +## libretro 宿主 + +固定 FCEUmm 提交见 `third_party/manifest.json`,构建定义在 `app/src/main/cpp/cmake/fceumm.cmake`。 +环境协商清单如下;不在清单中的请求统一返回 `false`。 + +| 类别 | 处理 | +| --- | --- | +| 私有目录 | system、save、content,必须可建立,否则阻止加载 | +| 视频 | 固定核心使用的 RGB565 与重复帧;其他像素格式拒绝 | +| 选项 | core-options version 0 与 `SET_VARIABLES/GET_VARIABLE` 默认值 | +| 输入 | player 1 joypad、bitmask、输入/控制器描述 | +| 前端信息 | 日志、英语、60 Hz/48 kHz 目标、动态 geometry/AV、消息接口 v1、性能级别、内存映射、成就/内容声明 | +| 明确不支持 | VFS、扩展 game-info、硬件渲染以及未列出的请求 | + +宿主在加载前核对 libretro API 版本和私有目录;必要能力缺失进入 Error。当前固定 FCEUmm 不把上述 +明确不支持的请求作为加载必要条件。 + +加载、`retro_run`、重置、卸载和保存内存访问均在内核线程执行。时序来自 +`retro_get_system_av_info`,以 `steady_clock` 调度;M2 完整消费音频回调并返回已消费帧数,但按阶段 +要求暂不发声。 + +## 视频、输入和电池存档 + +视频回调逐行按 pitch 复制到原生 latest-only 缓冲;`data == nullptr` 表示重复帧并保留上一完整帧。 +GL 线程只在原生侧读取最新缓冲和上传纹理,不经 JNI 逐帧复制图像。默认 4:3、最近邻显示,可切换 +原始像素整数缩放;渲染掉帧不减少内核 `retro_run` 次数。 + +手柄状态在 Android 事件侧合成为 libretro joypad 位掩码,内核每帧按状态采样。后台、失焦和断柄 +会清零并请求暂停。M1 的 X5 Lite 实测键码仍须在 G1 回填,因此当前只包含 Android 标准按键及 +HAT/主方向轴映射。 + +电池存档按 ROM 哈希隔离为 `files/saves//battery/battery.sav`。暂停和正常退出时在内核线程 +取得保存内存并以临时文件替换提交,状态通知用 `paused_saved`/`stopped_saved` 报告成功。更完整的 +备份、故障注入和恢复保证属于 M5,不在此处提前声明。 diff --git a/docs/build.md b/docs/build.md index 52c0874..1b7fa5f 100644 --- a/docs/build.md +++ b/docs/build.md @@ -1,6 +1,6 @@ # NESLite 可复现构建说明 -本说明对应 M0 基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 +本说明对应 M0~M2 基线。命令使用系统默认 PowerShell 7.6.6(`pwsh`)从仓库根目录执行;不需要手工复制 `.so`、 FCEUmm 或 Oboe 文件。 ## 前置条件 @@ -17,7 +17,7 @@ FCEUmm 或 Oboe 文件。 .\tools\fetch-third-party.ps1 ``` - 该脚本根据 `third_party/manifest.json` 检出固定提交;M0 的 JNI stub 不依赖这些源码。 + 该脚本根据 `third_party/manifest.json` 检出固定提交;M2 构建需要 FCEUmm 与 libretro headers。 ## 构建调试 APK @@ -35,9 +35,9 @@ pwsh -NoProfile -File .\tools\check.ps1 -Scope Build | `pwsh -NoProfile -File ./tools/check.ps1 -Scope Build` | 生成调试 APK | 单元、原生、实机、长测 | | `pwsh -NoProfile -File ./tools/check.ps1 -Scope Local` | Kotlin 本地单元测试 | APK、原生、实机、长测 | | `pwsh -NoProfile -File ./tools/check.ps1 -Scope Module` | 原生 smoke test 与 Kotlin 本地单测 | APK、实机、长测 | -| `pwsh -NoProfile -File ./tools/check.ps1 -Scope Stage` | M0 构建加上述有界测试 | 设备、耐久、H 专项 | +| `pwsh -NoProfile -File ./tools/check.ps1 -Scope Stage` | 当前 APK、原生 smoke test 与 Kotlin 本地单测 | 设备、ROM 兼容、耐久、H 专项 | -`Stage` 是 M0 的阶段入口,不是未来 G1~G9 的替代。实机、ROM、存档、插拔和耐久验收必须在 +`Stage` 是本地阶段入口,不是 G1~G9 的替代。实机、ROM、存档、插拔和耐久验收必须在 相应里程碑按 [acceptance.md](acceptance.md) 执行和记录。 ## M1 诊断版安装 diff --git a/docs/identity.md b/docs/identity.md index 21f01e4..9dee53a 100644 --- a/docs/identity.md +++ b/docs/identity.md @@ -6,7 +6,7 @@ | --- | --- | | 显示名称 | `NESLite` | | 正式 application ID/namespace | `org.neslite.app` | -| 当前开发版本 | `0.1.3`,`versionCode = 1003` | +| 当前开发版本 | `0.2.4`,`versionCode = 2004` | | 调试 application ID | `org.neslite.app.debug` | | 发布 ABI | `arm64-v8a` | | min/target SDK | 28/36 | diff --git a/docs/reports/m2-foundation.md b/docs/reports/m2-foundation.md new file mode 100644 index 0000000..86ae65b --- /dev/null +++ b/docs/reports/m2-foundation.md @@ -0,0 +1,37 @@ +# M2 内核、画面与基础操作记录 + +日期:2026-09-12 +构建:`org.neslite.app.debug`,`0.2.4-debug`,versionCode 2004,arm64-v8a + +APK:`app/build/outputs/apk/debug/app-debug.apk`,19,140,125 bytes,SHA-256 +`C29E5664AFAC2736D3BA76FC091FB9ECC711596A88A7FFB66114CDDC141D3038`。 + +## 已实现 + +- 固定 FCEUmm `236ccdfc911e84c60fea6b9d0699c2d440a8de14`,无本地补丁;以 + `__LIBRETRO__`、`FRONTEND_SUPPORTS_RGB565`、`HAVE_NTSC_FILTER`、`PSS_STYLE=1` 编译并静态链接 + 到 `libneslite_jni.so`。 +- 单原生线程、32 项有界命令队列、递增会话号、完整 M2 状态集合、完成序号和结果通知;旧会话不能 + 激活当前内核。 +- FCEUmm 环境协商、生命周期、AV 时序、静音音频消费、latest-only 原生视频缓冲和 GLES2 最近邻 + 显示;4:3 与整数像素缩放可切换。 +- SAF 流式导入、64 MiB 上限、iNES/NES 2.0 校验、完整 SHA-256、Room 最小索引、重复内容去重、 + 中断恢复和缺失文件状态。 +- 标准 Android 手柄键/HAT 状态送入 libretro;后台、失焦、断柄清零并暂停;界面提供加载、运行、 + 暂停、继续、重置和退出。 +- 按 ROM 哈希读取/提交基础电池存档,暂停和正常退出报告保存成功。 + +## 本地验证 + +- `:app:testDebugUnitTest`:12 项通过,包括构建身份、iNES/NES 2.0/损坏头/短文件、流式复制/ + 超限清理和 M1 输入测试。 +- `:app:assembleDebug`:通过;完整 FCEUmm 源码编译并链接 arm64-v8a APK。 +- `llvm-nm` 在最终未剥离 arm64 库中确认 `retro_api_version`、`retro_get_system_info`、 + `retro_load_game` 和 `retro_run` 入口。 +- 原生 smoke test 覆盖允许/拒绝状态、必要能力、新旧会话号、非紧密 pitch、重复帧和缓冲切换分支。 + +## 尚未形成门槛证据 + +G1 未通过,且目标手机、X5 Lite 和 3 个有合法使用依据的 ROM 样本(其中一个电池存档样本)均不在 +当前可用范围。因此 SAF 中文文件名/取消、GL 实际画面、组合输入、完整控制流程、电池进度恢复及 +3-ROM 兼容结果尚不能进行 L2/L3 验收;`todo.md` 中的 M2 项和 G2 均保持未勾选。 diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index ad70174..f5d69db 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -16,6 +16,7 @@ androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidx androidx-activity-ktx = { module = "androidx.activity:activity-ktx", version.ref = "androidxActivity" } androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" } androidx-room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" } +androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" } androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastore" } junit = { module = "junit:junit", version.ref = "junit" } json = { module = "org.json:json", version.ref = "json" } diff --git a/todo.md b/todo.md index c2d40dc..f9c5ef2 100644 --- a/todo.md +++ b/todo.md @@ -118,6 +118,10 @@ G1~G8 的共同交付物为对应阶段 APK、源码提交、构建说明、 ### M2/0.2.x:内核、画面与基础操作 +状态(2026-09-12):以下项目的隔离实现已进入 `0.2.4-debug`,本地构建和单元测试通过,详见 +`docs/reports/m2-foundation.md`。依照本文件的阶段门规则,G1 尚未通过且没有目标手机/3 个合法 +ROM 样本,因此所有需要 L2/L3 的 M2 项和 G2 继续保持未勾选,不以桌面测试替代实机验收。 + - [ ] **M2-01a 编译固定内核**。前置:无。完成:FCEUmm 链接到原生宿主,记录构建选项/补丁并冻结实际编译通过的提交。验收:L1,arm64 目标链接成功、导出入口与 API 版本可检查。 - [ ] **M2-04a 建立单线程会话执行器**。前置:M2-01a。完成:单内核线程、有界命令队列、会话编号及 Idle/Loading/Paused/Running/Pausing/Stopping/Error 状态;定义命令完成通知。验收:L1,状态转换和重复/迟到命令用最小序列验证,旧会话不能被重新激活。 - [ ] **M2-01b 实现环境协商**。前置:M2-04a。完成:按内核要求注册回调、目录、配置和玩家一设备;不支持请求返回失败,必要能力缺失阻止加载;形成支持清单。验收:L1,支持、不支持和缺少必要能力各验证一条不同分支。