android: fix a bug in music handling,

- remove service_provider member from MusicManager, it is not needed
- android handle a few special events

Author: Totto16

src/executables/game/application.cpp

@@ -119,6 +119,11 @@ void Application::handle_event(const SDL_Event& event) {
         m_is_running = false;
     }
 
+    // special event for android and IOS
+    if (event.type == SDL_APP_TERMINATING) {
+        m_is_running = false;
+    }
+
     auto handled = false;
 
     for (const auto& scene : std::ranges::views::reverse(m_scene_stack)) {
@@ -301,7 +306,6 @@ void Application::initialize() {
                                                            : 0s;
     auto start_execution_time = std::chrono::steady_clock::now();
 
-
     bool finished_loading = false;
 
     // this is a duplicate of below in some cases, but it's just for the loading screen and can't be factored out easily
@@ -324,6 +328,15 @@ void Application::initialize() {
             if (event.type == SDL_QUIT) {
                 m_is_running = false;
             }
+
+            // special event for android and IOS
+            if (event.type == SDL_APP_TERMINATING) {
+                m_is_running = false;
+            }
+        }
+
+        if (not m_is_running) {
+            break;
         }
 
         loading_screen.update();
@@ -355,12 +368,12 @@ void Application::initialize() {
 
     const auto duration = std::chrono::milliseconds(SDL_GetTicks64() - start_time);
 
-    // we can reach this via SDL_QUIT or (not console::inMainLoop())
-    if (not finished_loading) {
+    // we can reach this via SDL_QUIT, SDL_APP_TERMINATING or (not console::inMainLoop())
+    if (not finished_loading or not m_is_running) {
 
         spdlog::debug("Aborted loading after {}", duration);
 
-        // just exit immediately, without cleaning up, since than we would have to cancel the loading thread somehow, which is way rto complicated, let the OS clean up our mess we create her xD
+        // just exit immediately, without cleaning up, since than we would have to cancel the loading thread somehow, which is way to complicated, let the OS clean up our mess we created here xD
 
         utils::exit(0);
     }

src/input/input.cpp

@@ -151,7 +151,38 @@ input::InputManager::InputManager(const std::shared_ptr<Window>& window) {
                     break;
             }
             break;
+            //TODO(Totto): handle those types correctly, to e.g. pause the game automatically on background enter
+        case SDL_APP_TERMINATING:
+            /* Terminate the app.
+               Shut everything down before returning from this function.
+            */
+            return true;
+        case SDL_APP_LOWMEMORY:
+            /* You will get this when your app is paused and iOS wants more memory.
+               Release as much memory as possible.
+            */
+            return true;
+        case SDL_APP_WILLENTERBACKGROUND:
+            /* Prepare your app to go into the background.  Stop loops, etc.
+               This gets called when the user hits the home button, or gets a call.
+            */
+            return true;
+        case SDL_APP_DIDENTERBACKGROUND:
+            /* This will get called if the user accepted whatever sent your app to the background.
+               If the user got a phone call and canceled it, you'll instead get an SDL_APP_DID_ENTER_FOREGROUND event and restart your loops.
+               When you get this, you have 5 seconds to save all your state or the app will be terminated.
+               Your app is NOT active at this point.
+            */
+            return true;
+        case SDL_APP_WILLENTERFOREGROUND:
+            /* This call happens when your app is coming back to the foreground.
+               Restore all your state here.
+            */
+            return true;
+        case SDL_APP_DIDENTERFOREGROUND:
+
         default:
+
             break;
     }
 

src/manager/music_manager.cpp

@@ -19,10 +19,12 @@ MusicManager::MusicManager(ServiceProvider* service_provider, u8 channel_size)
       m_queued_music{ nullptr },
       m_channel_size{ channel_size },
       m_chunk_map{ std::unordered_map<std::string, Mix_Chunk*>{} },
-      m_service_provider{ service_provider },
-      m_volume{ m_service_provider->command_line_arguments().silent ? std::nullopt : std::optional{ 1.0F } } {
+      m_volume{ service_provider->command_line_arguments().silent ? std::nullopt : std::optional{ 1.0F } } {
     if (s_instance != nullptr) {
-        spdlog::error("it's not allowed to create more than one MusicManager instance");
+        spdlog::error(
+                "it's not allowed to create more than one MusicManager instance: {} != {}",
+                static_cast<void*>(s_instance), static_cast<void*>(this)
+        );
         return;
     }
 
@@ -37,13 +39,21 @@ MusicManager::MusicManager(ServiceProvider* service_provider, u8 channel_size)
         throw helper::InitializationError{ fmt::format("Failed to initialize any audio codec: {}", SDL_GetError()) };
     }
 
-    // see: https://wiki.libsdl.org/SDL2_mixer/Mix_AllocateChannels
-    auto allocated_channels = Mix_AllocateChannels(channel_size);
-    if (allocated_channels != channel_size) {
-        throw helper::InitializationError{ fmt::format(
-                "Failed to initialize the requested channels, requested {} but only got {}: {}", channel_size,
-                allocated_channels, SDL_GetError()
-        ) };
+    // retrieve allocated channels
+    auto allocated_channels = Mix_AllocateChannels(-1);
+
+    spdlog::debug("SDL_MIX: allocated_channels = {}", allocated_channels);
+
+    if (allocated_channels == 0) {
+
+        // see: https://wiki.libsdl.org/SDL2_mixer/Mix_AllocateChannels
+        auto newly_allocated_channels = Mix_AllocateChannels(channel_size);
+        if (newly_allocated_channels != channel_size) {
+            throw helper::InitializationError{ fmt::format(
+                    "Failed to initialize the requested channels, requested {} but only got {}: {}", channel_size,
+                    newly_allocated_channels, SDL_GetError()
+            ) };
+        }
     }
 
     // 2 here means STEREO, note that channels above means tracks, e.g. simultaneous playing source that are mixed,
@@ -66,7 +76,10 @@ MusicManager::~MusicManager() noexcept {
     }
 
     // stop sounds and free loaded data
-    Mix_HaltChannel(-1);
+    int result = Mix_HaltChannel(-1);
+    if (result != 0) {
+        spdlog::warn("Mix_HaltChannel failed with error: {}", SDL_GetError());
+    }
 
     if (m_music != nullptr) {
         Mix_FreeMusic(m_music);
@@ -79,8 +92,11 @@ MusicManager::~MusicManager() noexcept {
     for (const auto& [_, value] : m_chunk_map) {
         Mix_FreeChunk(value);
     }
+
     Mix_CloseAudio();
     Mix_Quit();
+
+    s_instance = nullptr;
 }
 
 std::optional<std::string> MusicManager::load_and_play_music(const std::filesystem::path& location, const usize delay) {
@@ -141,7 +157,11 @@ std::optional<std::string> MusicManager::load_and_play_music(const std::filesyst
         m_queued_music = music;
         m_delay = delay;
         Mix_HookMusicFinished([]() {
-            assert(s_instance != nullptr and "there must be a MusicManager instance");
+            // this can happen on e.g. android, where if we exit the application, we don't close the window, so its reused, but the music manager is destroyed, but the hook is called later xD
+            /* if (s_instance == nullptr) {
+                return;
+            } */
+
             s_instance->hook_music_finished();
         });
 
@@ -232,7 +252,10 @@ void MusicManager::hook_music_finished() {
 
 [[nodiscard]] bool MusicManager::validate_instance() {
     if (s_instance != this) {
-        spdlog::error("this MusicManager instance is not the instance that is used globally");
+        spdlog::error(
+                "this MusicManager instance is not the instance that is used globally: {} != {}",
+                static_cast<void*>(s_instance), static_cast<void*>(this)
+        );
         return false;
     }
     return true;

src/manager/music_manager.hpp

@@ -30,16 +30,19 @@ struct MusicManager final {
     std::unordered_map<std::string, Mix_Chunk*> m_chunk_map;
     static constexpr unsigned fade_ms = 500;
     usize m_delay = MusicManager::fade_ms;
-    ServiceProvider* m_service_provider;
+
     std::optional<double> m_volume;
     std::unordered_map<std::string, VolumeChangeFunction> m_volume_listeners;
 
 public:
     explicit MusicManager(ServiceProvider* service_provider, u8 channel_size = 2);
+
     MusicManager(const MusicManager&) = delete;
     MusicManager& operator=(const MusicManager&) = delete;
+
     MusicManager(const MusicManager&&) = delete;
     MusicManager& operator=(MusicManager&&) = delete;
+
     ~MusicManager() noexcept;
 
     std::optional<std::string>