Apply clang-format to all c++ android files

src/android/app/src/main/cpp/AndroidAudio.cpp

@@ -5,52 +5,52 @@
 
 #if HAS_CUBEB
 #include "audio/CubebAPI.h"
-#endif  // HAS_CUBEB
+#endif // HAS_CUBEB
 
 namespace AndroidAudio
 {
 
-void createAudioDevice(IAudioAPI::AudioAPI audioApi, sint32 channels, sint32 volume, bool isTV)
-{
-    static constexpr int AX_FRAMES_PER_GROUP = 4;
-    std::unique_lock lock(g_audioMutex);
-    auto& audioDevice = isTV ? g_tvAudio : g_padAudio;
-    switch (channels)
-    {
-        case 0:
-            channels = 1;
-            break;
-        case 2:
-            channels = 6;
-            break;
-        default:  // stereo
-            channels = 2;
-            break;
-    }
-    switch (audioApi)
-    {
+	void createAudioDevice(IAudioAPI::AudioAPI audioApi, sint32 channels, sint32 volume, bool isTV)
+	{
+		static constexpr int AX_FRAMES_PER_GROUP = 4;
+		std::unique_lock lock(g_audioMutex);
+		auto& audioDevice = isTV ? g_tvAudio : g_padAudio;
+		switch (channels)
+		{
+		case 0:
+			channels = 1;
+			break;
+		case 2:
+			channels = 6;
+			break;
+		default: // stereo
+			channels = 2;
+			break;
+		}
+		switch (audioApi)
+		{
 #if HAS_CUBEB
-        case IAudioAPI::AudioAPI::Cubeb:
-        {
-            audioDevice.reset();
-            std::shared_ptr<CubebAPI::CubebDeviceDescription> deviceDescriptionPtr = std::make_shared<CubebAPI::CubebDeviceDescription>(nullptr, std::string(), std::wstring());
-            audioDevice = IAudioAPI::CreateDevice(IAudioAPI::AudioAPI::Cubeb, deviceDescriptionPtr, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
-            audioDevice->SetVolume(volume);
-            break;
-        }
-#endif  // HAS_CUBEB
-        default:
-            cemuLog_log(LogType::Force, fmt::format("Invalid audio api: {}", audioApi));
-            break;
-    }
-}
+		case IAudioAPI::AudioAPI::Cubeb:
+		{
+			audioDevice.reset();
+			std::shared_ptr<CubebAPI::CubebDeviceDescription> deviceDescriptionPtr = std::make_shared<CubebAPI::CubebDeviceDescription>(nullptr, std::string(), std::wstring());
+			audioDevice = IAudioAPI::CreateDevice(IAudioAPI::AudioAPI::Cubeb, deviceDescriptionPtr, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
+			audioDevice->SetVolume(volume);
+			break;
+		}
+#endif // HAS_CUBEB
+		default:
+			cemuLog_log(LogType::Force, "Invalid audio api: {}", audioApi);
+			break;
+		}
+	}
 
-void setAudioVolume(sint32 volume, bool isTV)
-{
-    std::shared_lock lock(g_audioMutex);
-    auto& audioDevice = isTV ? g_tvAudio : g_padAudio;
-    if (audioDevice)
-        audioDevice->SetVolume(volume);
-}
+	void setAudioVolume(sint32 volume, bool isTV)
+	{
+		std::shared_lock lock(g_audioMutex);
+		auto& audioDevice = isTV ? g_tvAudio : g_padAudio;
+		if (audioDevice)
+			audioDevice->SetVolume(volume);
+	}
 
-};  // namespace AndroidAudio
+}; // namespace AndroidAudio

src/android/app/src/main/cpp/AndroidAudio.h

@@ -4,6 +4,6 @@
 
 namespace AndroidAudio
 {
-void createAudioDevice(IAudioAPI::AudioAPI audioApi, sint32 channels, sint32 volume, bool isTV = true);
-void setAudioVolume(sint32 volume, bool isTV = true);
-};  // namespace AndroidAudio
+	void createAudioDevice(IAudioAPI::AudioAPI audioApi, sint32 channels, sint32 volume, bool isTV = true);
+	void setAudioVolume(sint32 volume, bool isTV = true);
+}; // namespace AndroidAudio

src/android/app/src/main/cpp/AndroidEmulatedController.h

@@ -6,21 +6,21 @@
 #include "input/emulated/ProController.h"
 #include "input/emulated/WiimoteController.h"
 
-class AndroidEmulatedController
-{
-   private:
+class AndroidEmulatedController {
+  private:
 	size_t m_index;
 	static std::array<std::unique_ptr<AndroidEmulatedController>, InputManager::kMaxController> s_emulatedControllers;
 	EmulatedControllerPtr m_emulatedController;
-	AndroidEmulatedController(size_t index) : m_index(index)
+	AndroidEmulatedController(size_t index)
+		: m_index(index)
 	{
 		m_emulatedController = InputManager::instance().get_controller(m_index);
 	}
 
-   public:
-	static AndroidEmulatedController &getAndroidEmulatedController(size_t index)
+  public:
+	static AndroidEmulatedController& getAndroidEmulatedController(size_t index)
 	{
-		auto &controller = s_emulatedControllers.at(index);
+		auto& controller = s_emulatedControllers.at(index);
 		if (!controller)
 			controller = std::unique_ptr<AndroidEmulatedController>(new AndroidEmulatedController(index));
 		return *controller;
@@ -36,9 +36,8 @@ class AndroidEmulatedController
 	{
 		if (m_emulatedController && controller)
 		{
-			const auto &controllers = m_emulatedController->get_controllers();
-			auto controllerIt = std::find_if(controllers.begin(), controllers.end(), [&](const ControllerPtr &c)
-			                                 { return c->api() == controller->api() && c->uuid() == controller->uuid(); });
+			const auto& controllers = m_emulatedController->get_controllers();
+			auto controllerIt = std::find_if(controllers.begin(), controllers.end(), [&](const ControllerPtr& c) { return c->api() == controller->api() && c->uuid() == controller->uuid(); });
 			if (controllerIt == controllers.end())
 				m_emulatedController->add_controller(controller);
 			else

src/android/app/src/main/cpp/AndroidFilesystemCallbacks.h

@@ -3,15 +3,14 @@
 #include "JNIUtils.h"
 #include "Common/unix/FilesystemAndroid.h"
 
-class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
-{
+class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks {
 	jmethodID m_openContentUriMid;
 	jmethodID m_listFilesMid;
 	jmethodID m_isDirectoryMid;
 	jmethodID m_isFileMid;
 	jmethodID m_existsMid;
 	JNIUtils::Scopedjclass m_fileUtilClass;
-	std::function<void(JNIEnv *)> m_function = nullptr;
+	std::function<void(JNIEnv*)> m_function = nullptr;
 	std::mutex m_functionMutex;
 	std::condition_variable m_functionCV;
 	std::thread m_thread;
@@ -19,13 +18,12 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 	std::condition_variable m_threadCV;
 	std::atomic_bool m_continue = true;
 
-	bool callBooleanFunction(const std::filesystem::path &uri, jmethodID methodId)
+	bool callBooleanFunction(const std::filesystem::path& uri, jmethodID methodId)
 	{
 		std::lock_guard lock(m_functionMutex);
 		bool functionFinished = false;
 		bool result = false;
-		m_function = [&, this](JNIEnv *env)
-		{
+		m_function = [&, this](JNIEnv* env) {
 			jstring uriString = env->NewStringUTF(uri.c_str());
 			result = env->CallStaticBooleanMethod(*m_fileUtilClass, methodId, uriString);
 			env->DeleteLocalRef(uriString);
@@ -34,8 +32,7 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		m_threadCV.notify_one();
 		{
 			std::unique_lock threadLock(m_threadMutex);
-			m_functionCV.wait(threadLock, [&]() -> bool
-			                  { return functionFinished; });
+			m_functionCV.wait(threadLock, [&]() -> bool { return functionFinished; });
 		}
 		return result;
 	}
@@ -46,8 +43,7 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		while (m_continue)
 		{
 			std::unique_lock threadLock(m_threadMutex);
-			m_threadCV.wait(threadLock, [&]
-			                { return m_function || !m_continue; });
+			m_threadCV.wait(threadLock, [&] { return m_function || !m_continue; });
 			if (!m_continue)
 				return;
 			m_function(*env);
@@ -56,7 +52,7 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		}
 	}
 
-   public:
+  public:
 	AndroidFilesystemCallbacks()
 	{
 		JNIUtils::ScopedJNIENV env;
@@ -76,13 +72,12 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		m_thread.join();
 	}
 
-	int openContentUri(const std::filesystem::path &uri) override
+	int openContentUri(const std::filesystem::path& uri) override
 	{
 		std::lock_guard lock(m_functionMutex);
 		bool functionFinished = false;
 		int fd = -1;
-		m_function = [&, this](JNIEnv *env)
-		{
+		m_function = [&, this](JNIEnv* env) {
 			jstring uriString = env->NewStringUTF(uri.c_str());
 			fd = env->CallStaticIntMethod(*m_fileUtilClass, m_openContentUriMid, uriString);
 			env->DeleteLocalRef(uriString);
@@ -91,19 +86,17 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		m_threadCV.notify_one();
 		{
 			std::unique_lock threadLock(m_threadMutex);
-			m_functionCV.wait(threadLock, [&]()
-			                  { return functionFinished; });
+			m_functionCV.wait(threadLock, [&]() { return functionFinished; });
 		}
 		return fd;
 	}
 
-	std::vector<std::filesystem::path> listFiles(const std::filesystem::path &uri) override
+	std::vector<std::filesystem::path> listFiles(const std::filesystem::path& uri) override
 	{
 		std::lock_guard lock(m_functionMutex);
 		bool functionFinished = false;
 		std::vector<std::filesystem::path> paths;
-		m_function = [&, this](JNIEnv *env)
-		{
+		m_function = [&, this](JNIEnv* env) {
 			jstring uriString = env->NewStringUTF(uri.c_str());
 			jobjectArray pathsObjArray = static_cast<jobjectArray>(env->CallStaticObjectMethod(*m_fileUtilClass, m_listFilesMid, uriString));
 			env->DeleteLocalRef(uriString);
@@ -121,23 +114,22 @@ class AndroidFilesystemCallbacks : public FilesystemAndroid::FilesystemCallbacks
 		m_threadCV.notify_one();
 		{
 			std::unique_lock threadLock(m_threadMutex);
-			m_functionCV.wait(threadLock, [&]()
-			                  { return functionFinished; });
+			m_functionCV.wait(threadLock, [&]() { return functionFinished; });
 		}
 		return paths;
 	}
 
-	bool isDirectory(const std::filesystem::path &uri) override
+	bool isDirectory(const std::filesystem::path& uri) override
 	{
 		return callBooleanFunction(uri, m_isDirectoryMid);
 	}
 
-	bool isFile(const std::filesystem::path &uri) override
+	bool isFile(const std::filesystem::path& uri) override
 	{
 		return callBooleanFunction(uri, m_isFileMid);
 	}
 
-	bool exists(const std::filesystem::path &uri) override
+	bool exists(const std::filesystem::path& uri) override
 	{
 		return callBooleanFunction(uri, m_existsMid);
 	}

src/android/app/src/main/cpp/AndroidGameIconLoadedCallback.h

@@ -3,14 +3,13 @@
 #include "GameIconLoader.h"
 #include "JNIUtils.h"
 
-class AndroidGameIconLoadedCallback : public GameIconLoadedCallback
-{
+class AndroidGameIconLoadedCallback : public GameIconLoadedCallback {
 	jmethodID m_onGameIconLoadedMID;
 	JNIUtils::Scopedjobject m_gameTitleLoadedCallbackObj;
 
-   public:
+  public:
 	AndroidGameIconLoadedCallback(jmethodID onGameIconLoadedMID,
-	                              jobject gameTitleLoadedCallbackObj)
+								  jobject gameTitleLoadedCallbackObj)
 		: m_onGameIconLoadedMID(onGameIconLoadedMID),
 		  m_gameTitleLoadedCallbackObj(gameTitleLoadedCallbackObj) {}
 

src/android/app/src/main/cpp/AndroidGameTitleLoadedCallback.h

@@ -2,21 +2,20 @@
 
 #include "GameTitleLoader.h"
 
-class AndroidGameTitleLoadedCallback : public GameTitleLoadedCallback
-{
+class AndroidGameTitleLoadedCallback : public GameTitleLoadedCallback {
 	jmethodID m_onGameTitleLoadedMID;
 	JNIUtils::Scopedjobject m_gameTitleLoadedCallbackObj;
 
-   public:
+  public:
 	AndroidGameTitleLoadedCallback(jmethodID onGameTitleLoadedMID, jobject gameTitleLoadedCallbackObj)
 		: m_onGameTitleLoadedMID(onGameTitleLoadedMID),
 		  m_gameTitleLoadedCallbackObj(gameTitleLoadedCallbackObj) {}
 
-	void onTitleLoaded(const Game &game) override
+	void onTitleLoaded(const Game& game) override
 	{
 		JNIUtils::ScopedJNIENV env;
 		jstring name = env->NewStringUTF(game.name.c_str());
-		jlong titleId = *reinterpret_cast<const jlong *>(&game.titleId);
+		jlong titleId = *reinterpret_cast<const jlong*>(&game.titleId);
 		env->CallVoidMethod(*m_gameTitleLoadedCallbackObj, m_onGameTitleLoadedMID, titleId, name);
 		env->DeleteLocalRef(name);
 	}

src/android/app/src/main/cpp/CafeSystemUtils.cpp

@@ -5,48 +5,48 @@
 
 namespace CafeSystemUtils
 {
-void startGame(TitleId titleId)
-{
-	TitleInfo launchTitle;
-
-	if (!CafeTitleList::GetFirstByTitleId(titleId, launchTitle))
-		return;
-
-	if (launchTitle.IsValid())
+	void startGame(TitleId titleId)
 	{
-		// the title might not be in the TitleList, so we add it as a temporary entry
-		CafeTitleList::AddTitleFromPath(launchTitle.GetPath());
-		// title is valid, launch from TitleId
-		TitleId baseTitleId;
-		if (!CafeTitleList::FindBaseTitleId(launchTitle.GetAppTitleId(), baseTitleId))
+		TitleInfo launchTitle;
+
+		if (!CafeTitleList::GetFirstByTitleId(titleId, launchTitle))
+			return;
+
+		if (launchTitle.IsValid())
 		{
-		}
-		CafeSystem::STATUS_CODE statusCode = CafeSystem::PrepareForegroundTitle(baseTitleId);
-		if (statusCode == CafeSystem::STATUS_CODE::INVALID_RPX)
-		{
-		}
-		else if (statusCode == CafeSystem::STATUS_CODE::UNABLE_TO_MOUNT)
-		{
-		}
-		else if (statusCode != CafeSystem::STATUS_CODE::SUCCESS)
-		{
-		}
-	}
-	else  // if (launchTitle.GetFormat() == TitleInfo::TitleDataFormat::INVALID_STRUCTURE )
-	{
-		// title is invalid, if its an RPX/ELF we can launch it directly
-		// otherwise its an error
-		CafeTitleFileType fileType = DetermineCafeSystemFileType(launchTitle.GetPath());
-		if (fileType == CafeTitleFileType::RPX || fileType == CafeTitleFileType::ELF)
-		{
-			CafeSystem::STATUS_CODE statusCode = CafeSystem::PrepareForegroundTitleFromStandaloneRPX(
-				launchTitle.GetPath());
-			if (statusCode != CafeSystem::STATUS_CODE::SUCCESS)
+			// the title might not be in the TitleList, so we add it as a temporary entry
+			CafeTitleList::AddTitleFromPath(launchTitle.GetPath());
+			// title is valid, launch from TitleId
+			TitleId baseTitleId;
+			if (!CafeTitleList::FindBaseTitleId(launchTitle.GetAppTitleId(), baseTitleId))
+			{
+			}
+			CafeSystem::STATUS_CODE statusCode = CafeSystem::PrepareForegroundTitle(baseTitleId);
+			if (statusCode == CafeSystem::STATUS_CODE::INVALID_RPX)
+			{
+			}
+			else if (statusCode == CafeSystem::STATUS_CODE::UNABLE_TO_MOUNT)
+			{
+			}
+			else if (statusCode != CafeSystem::STATUS_CODE::SUCCESS)
 			{
-				return;
 			}
 		}
+		else // if (launchTitle.GetFormat() == TitleInfo::TitleDataFormat::INVALID_STRUCTURE )
+		{
+			// title is invalid, if its an RPX/ELF we can launch it directly
+			// otherwise its an error
+			CafeTitleFileType fileType = DetermineCafeSystemFileType(launchTitle.GetPath());
+			if (fileType == CafeTitleFileType::RPX || fileType == CafeTitleFileType::ELF)
+			{
+				CafeSystem::STATUS_CODE statusCode = CafeSystem::PrepareForegroundTitleFromStandaloneRPX(
+					launchTitle.GetPath());
+				if (statusCode != CafeSystem::STATUS_CODE::SUCCESS)
+				{
+					return;
+				}
+			}
+		}
+		CafeSystem::LaunchForegroundTitle();
 	}
-	CafeSystem::LaunchForegroundTitle();
-}
-};  // namespace CafeSystemUtils
+}; // namespace CafeSystemUtils

src/android/app/src/main/cpp/CafeSystemUtils.h

@@ -4,5 +4,5 @@
 
 namespace CafeSystemUtils
 {
-void startGame(TitleId titleId);
+	void startGame(TitleId titleId);
 };

src/android/app/src/main/cpp/EmulationState.h

@@ -260,11 +260,42 @@ class EmulationState {
 
 	void setEnabledStateForGraphicPack(int64_t id, bool state)
 	{
-		m_graphicPacks.at(id)->SetEnabled(state);
+		auto graphicPack = m_graphicPacks.at(id);
+		graphicPack->SetEnabled(state);
+		saveGraphicPackStateToConfig(graphicPack);
 	}
 
 	GraphicPackPtr getGraphicPack(int64_t id) const
 	{
 		return m_graphicPacks.at(id);
 	}
+	void setGraphicPackActivePreset(int64_t id, const std::string& presetCategory, const std::string& preset) const
+	{
+		auto graphicPack = m_graphicPacks.at(id);
+		graphicPack->SetActivePreset(presetCategory, preset);
+		saveGraphicPackStateToConfig(graphicPack);
+	}
+	void saveGraphicPackStateToConfig(GraphicPackPtr graphicPack) const
+	{
+		auto& data = g_config.data();
+		auto filename = _utf8ToPath(graphicPack->GetNormalizedPathString());
+		if (data.graphic_pack_entries.contains(filename))
+			data.graphic_pack_entries.erase(filename);
+		if (graphicPack->IsEnabled())
+		{
+			data.graphic_pack_entries.try_emplace(filename);
+			auto& it = data.graphic_pack_entries[filename];
+			// otherwise store all selected presets
+			for (const auto& preset : graphicPack->GetActivePresets())
+				it.try_emplace(preset->category, preset->name);
+		}
+		else if (graphicPack->IsDefaultEnabled())
+		{
+			// save that its disabled
+			data.graphic_pack_entries.try_emplace(filename);
+			auto& it = data.graphic_pack_entries[filename];
+			it.try_emplace("_disabled", "false");
+		}
+		g_config.Save();
+	}
 };

src/android/app/src/main/cpp/GameIconLoader.cpp

@@ -15,7 +15,7 @@ GameIconLoader::~GameIconLoader()
 	m_loaderThread.join();
 }
 
-const Image &GameIconLoader::getGameIcon(TitleId titleId)
+const Image& GameIconLoader::getGameIcon(TitleId titleId)
 {
 	return m_iconCache.at(titleId);
 }
@@ -36,8 +36,7 @@ void GameIconLoader::loadGameIcons()
 		TitleId titleId = 0;
 		{
 			std::unique_lock lock(m_threadMutex);
-			m_condVar.wait(lock, [this]
-			               { return !m_iconsToLoad.empty() || !m_continueLoading; });
+			m_condVar.wait(lock, [this] { return !m_iconsToLoad.empty() || !m_continueLoading; });
 			if (!m_continueLoading)
 				return;
 			titleId = m_iconsToLoad.front();
@@ -49,7 +48,7 @@ void GameIconLoader::loadGameIcons()
 
 		if (auto iconIt = m_iconCache.find(titleId); iconIt != m_iconCache.end())
 		{
-			auto &icon = iconIt->second;
+			auto& icon = iconIt->second;
 			if (m_onIconLoaded)
 				m_onIconLoaded->onIconLoaded(titleId, icon.intColors(), icon.m_width, icon.m_height);
 			continue;
@@ -77,7 +76,7 @@ void GameIconLoader::loadGameIcons()
 	}
 }
 
-void GameIconLoader::setOnIconLoaded(const std::shared_ptr<GameIconLoadedCallback> &onIconLoaded)
+void GameIconLoader::setOnIconLoaded(const std::shared_ptr<GameIconLoadedCallback>& onIconLoaded)
 {
 	{
 		std::lock_guard lock(m_threadMutex);

src/android/app/src/main/cpp/GameIconLoader.h

@@ -3,14 +3,12 @@
 #include "Cafe/TitleList/TitleId.h"
 #include "Image.h"
 
-class GameIconLoadedCallback
-{
-   public:
-	virtual void onIconLoaded(TitleId titleId, int *colors, int width, int height) = 0;
+class GameIconLoadedCallback {
+  public:
+	virtual void onIconLoaded(TitleId titleId, int* colors, int width, int height) = 0;
 };
 
-class GameIconLoader
-{
+class GameIconLoader {
 	std::condition_variable m_condVar;
 	std::atomic_bool m_continueLoading = true;
 	std::thread m_loaderThread;
@@ -19,17 +17,17 @@ class GameIconLoader
 	std::map<TitleId, Image> m_iconCache;
 	std::shared_ptr<GameIconLoadedCallback> m_onIconLoaded = nullptr;
 
-   public:
+  public:
 	GameIconLoader();
 
 	~GameIconLoader();
 
-	const Image &getGameIcon(TitleId titleId);
+	const Image& getGameIcon(TitleId titleId);
 
-	void setOnIconLoaded(const std::shared_ptr<GameIconLoadedCallback> &onIconLoaded);
+	void setOnIconLoaded(const std::shared_ptr<GameIconLoadedCallback>& onIconLoaded);
 
 	void requestIcon(TitleId titleId);
 
-   private:
+  private:
 	void loadGameIcons();
 };

src/android/app/src/main/cpp/GameTitleLoader.cpp

@@ -14,7 +14,7 @@ void GameTitleLoader::queueTitle(TitleId titleId)
 	m_condVar.notify_one();
 }
 
-void GameTitleLoader::setOnTitleLoaded(const std::shared_ptr<GameTitleLoadedCallback> &gameTitleLoadedCallback)
+void GameTitleLoader::setOnTitleLoaded(const std::shared_ptr<GameTitleLoadedCallback>& gameTitleLoadedCallback)
 {
 	{
 		std::lock_guard lock(m_threadMutex);
@@ -57,7 +57,7 @@ void GameTitleLoader::titleRefresh(TitleId titleId)
 		isNewEntry = true;
 		m_gameInfos[baseTitleId] = Game();
 	}
-	Game &game = m_gameInfos[baseTitleId];
+	Game& game = m_gameInfos[baseTitleId];
 	game.titleId = baseTitleId;
 	game.name = GetNameByTitleId(baseTitleId);
 	game.version = gameInfo.GetVersion();
@@ -87,9 +87,8 @@ void GameTitleLoader::loadGameTitles()
 		TitleId titleId = 0;
 		{
 			std::unique_lock lock(m_threadMutex);
-			m_condVar.wait(lock, [this]
-			               { return (!m_titlesToLoad.empty()) ||
-				                    !m_continueLoading; });
+			m_condVar.wait(lock, [this] { return (!m_titlesToLoad.empty()) ||
+												 !m_continueLoading; });
 			if (!m_continueLoading)
 				return;
 			titleId = m_titlesToLoad.front();
@@ -117,14 +116,13 @@ std::string GameTitleLoader::GetNameByTitleId(uint64 titleId)
 void GameTitleLoader::registerCallback()
 {
 	m_callbackIdTitleList = CafeTitleList::RegisterCallback(
-		[](CafeTitleListCallbackEvent *evt, void *ctx)
-		{
-			static_cast<GameTitleLoader *>(ctx)->HandleTitleListCallback(evt);
+		[](CafeTitleListCallbackEvent* evt, void* ctx) {
+			static_cast<GameTitleLoader*>(ctx)->HandleTitleListCallback(evt);
 		},
 		this);
 }
 
-void GameTitleLoader::HandleTitleListCallback(CafeTitleListCallbackEvent *evt)
+void GameTitleLoader::HandleTitleListCallback(CafeTitleListCallbackEvent* evt)
 {
 	if (evt->eventType == CafeTitleListCallbackEvent::TYPE::TITLE_DISCOVERED || evt->eventType == CafeTitleListCallbackEvent::TYPE::TITLE_REMOVED)
 	{
@@ -132,7 +130,7 @@ void GameTitleLoader::HandleTitleListCallback(CafeTitleListCallbackEvent *evt)
 	}
 }
 
-void GameTitleLoader::addGamePath(const fs::path &path)
+void GameTitleLoader::addGamePath(const fs::path& path)
 {
 	CafeTitleList::ClearScanPaths();
 	CafeTitleList::AddScanPath(path);

src/android/app/src/main/cpp/GameTitleLoader.h

@@ -14,14 +14,12 @@ struct Game
 	CafeConsoleRegion region;
 };
 
-class GameTitleLoadedCallback
-{
-   public:
-	virtual void onTitleLoaded(const Game &game) = 0;
+class GameTitleLoadedCallback {
+  public:
+	virtual void onTitleLoaded(const Game& game) = 0;
 };
 
-class GameTitleLoader
-{
+class GameTitleLoader {
 	std::mutex m_threadMutex;
 	std::condition_variable m_condVar;
 	std::thread m_loaderThread;
@@ -32,12 +30,12 @@ class GameTitleLoader
 	std::map<TitleId, std::string> m_name_cache;
 	std::shared_ptr<GameTitleLoadedCallback> m_gameTitleLoadedCallback = nullptr;
 
-   public:
+  public:
 	GameTitleLoader();
 
 	void queueTitle(TitleId titleId);
 
-	void setOnTitleLoaded(const std::shared_ptr<GameTitleLoadedCallback> &gameTitleLoadedCallback);
+	void setOnTitleLoaded(const std::shared_ptr<GameTitleLoadedCallback>& gameTitleLoadedCallback);
 
 	void reloadGameTitles();
 
@@ -45,14 +43,14 @@ class GameTitleLoader
 
 	void titleRefresh(TitleId titleId);
 
-	void addGamePath(const fs::path &path);
+	void addGamePath(const fs::path& path);
 
-   private:
+  private:
 	void loadGameTitles();
 
 	std::string GetNameByTitleId(uint64 titleId);
 
 	void registerCallback();
 
-	void HandleTitleListCallback(CafeTitleListCallbackEvent *evt);
+	void HandleTitleListCallback(CafeTitleListCallbackEvent* evt);
 };

src/android/app/src/main/cpp/Image.cpp

@@ -5,7 +5,7 @@
 
 #include "stb_image.h"
 
-Image::Image(Image &&image)
+Image::Image(Image&& image)
 {
 	this->m_image = image.m_image;
 	this->m_width = image.m_width;
@@ -14,7 +14,7 @@ Image::Image(Image &&image)
 	image.m_image = nullptr;
 }
 
-Image::Image(const std::vector<uint8> &imageBytes)
+Image::Image(const std::vector<uint8>& imageBytes)
 {
 	m_image = stbi_load_from_memory(imageBytes.data(), imageBytes.size(), &m_width, &m_height, &m_channels, STBI_rgb_alpha);
 	if (m_image)
@@ -33,9 +33,15 @@ Image::Image(const std::vector<uint8> &imageBytes)
 	}
 }
 
-bool Image::isOk() const { return m_image != nullptr; }
+bool Image::isOk() const
+{
+	return m_image != nullptr;
+}
 
-int *Image::intColors() const { return reinterpret_cast<int *>(m_image); }
+int* Image::intColors() const
+{
+	return reinterpret_cast<int*>(m_image);
+}
 
 Image::~Image()
 {

src/android/app/src/main/cpp/Image.h

@@ -2,18 +2,18 @@
 
 struct Image
 {
-	uint8_t *m_image = nullptr;
+	uint8_t* m_image = nullptr;
 	int m_width = 0;
 	int m_height = 0;
 	int m_channels = 0;
 
-	Image(Image &&image);
+	Image(Image&& image);
 
-	Image(const std::vector<uint8> &imageBytes);
+	Image(const std::vector<uint8>& imageBytes);
 
 	bool isOk() const;
 
-	int *intColors() const;
+	int* intColors() const;
 
 	~Image();
 };

src/android/app/src/main/cpp/JNIUtils.cpp

@@ -2,68 +2,68 @@
 
 namespace JNIUtils
 {
-JavaVM *g_jvm = nullptr;
+	JavaVM* g_jvm = nullptr;
 };
 
-std::string JNIUtils::JStringToString(JNIEnv *env, jstring jstr)
+std::string JNIUtils::JStringToString(JNIEnv* env, jstring jstr)
 {
-    const char *c_str = env->GetStringUTFChars(jstr, nullptr);
-    std::string str(c_str);
-    env->ReleaseStringUTFChars(jstr, c_str);
-    return str;
+	const char* c_str = env->GetStringUTFChars(jstr, nullptr);
+	std::string str(c_str);
+	env->ReleaseStringUTFChars(jstr, c_str);
+	return str;
 }
 
-jobject JNIUtils::createJavaStringArrayList(JNIEnv *env, const std::vector<std::string> &strings)
+jobject JNIUtils::createJavaStringArrayList(JNIEnv* env, const std::vector<std::string>& strings)
 {
-    jclass clsArrayList = env->FindClass("java/util/ArrayList");
-    jmethodID arrayListConstructor = env->GetMethodID(clsArrayList, "<init>", "()V");
-    jobject arrayListObject = env->NewObject(clsArrayList, arrayListConstructor);
-    jmethodID addMethod = env->GetMethodID(clsArrayList, "add", "(Ljava/lang/Object;)Z");
-    env->DeleteLocalRef(clsArrayList);
+	jclass clsArrayList = env->FindClass("java/util/ArrayList");
+	jmethodID arrayListConstructor = env->GetMethodID(clsArrayList, "<init>", "()V");
+	jobject arrayListObject = env->NewObject(clsArrayList, arrayListConstructor);
+	jmethodID addMethod = env->GetMethodID(clsArrayList, "add", "(Ljava/lang/Object;)Z");
+	env->DeleteLocalRef(clsArrayList);
 
-    for (const auto &string : strings)
-    {
-        jstring element = env->NewStringUTF(string.c_str());
-        env->CallBooleanMethod(arrayListObject, addMethod, element);
-        env->DeleteLocalRef(element);
-    }
-    return arrayListObject;
+	for (const auto& string : strings)
+	{
+		jstring element = env->NewStringUTF(string.c_str());
+		env->CallBooleanMethod(arrayListObject, addMethod, element);
+		env->DeleteLocalRef(element);
+	}
+	return arrayListObject;
 }
 
-JNIUtils::Scopedjobject JNIUtils::getEnumValue(JNIEnv *env, const std::string &enumClassName, const std::string &enumName)
+JNIUtils::Scopedjobject JNIUtils::getEnumValue(JNIEnv* env, const std::string& enumClassName, const std::string& enumName)
 {
-    jclass enumClass = env->FindClass(enumClassName.c_str());
-    jfieldID fieldID = env->GetStaticFieldID(enumClass, enumName.c_str(), ("L" + enumClassName + ";").c_str());
-    jobject enumValue = env->GetStaticObjectField(enumClass, fieldID);
-    env->DeleteLocalRef(enumClass);
-    Scopedjobject enumObj = Scopedjobject(enumValue);
-    env->DeleteLocalRef(enumValue);
-    return enumObj;
+	jclass enumClass = env->FindClass(enumClassName.c_str());
+	jfieldID fieldID = env->GetStaticFieldID(enumClass, enumName.c_str(), ("L" + enumClassName + ";").c_str());
+	jobject enumValue = env->GetStaticObjectField(enumClass, fieldID);
+	env->DeleteLocalRef(enumClass);
+	Scopedjobject enumObj = Scopedjobject(enumValue);
+	env->DeleteLocalRef(enumValue);
+	return enumObj;
 }
 
-jobject JNIUtils::createArrayList(JNIEnv *env, const std::vector<jobject> &objects)
+jobject JNIUtils::createArrayList(JNIEnv* env, const std::vector<jobject>& objects)
 {
-    static Scopedjclass listClass = Scopedjclass("java/util/ArrayList");
-    static jmethodID listConstructor = env->GetMethodID(*listClass, "<init>", "()V");
-    static jmethodID listAdd = env->GetMethodID(*listClass, "add", "(Ljava/lang/Object;)Z");
+	static Scopedjclass listClass = Scopedjclass("java/util/ArrayList");
+	static jmethodID listConstructor = env->GetMethodID(*listClass, "<init>", "()V");
+	static jmethodID listAdd = env->GetMethodID(*listClass, "add", "(Ljava/lang/Object;)Z");
 
-    jobject arrayList = env->NewObject(*listClass, listConstructor);
-    for (auto &&obj : objects)
-        env->CallBooleanMethod(arrayList, listAdd, obj);
-    return arrayList;
+	jobject arrayList = env->NewObject(*listClass, listConstructor);
+	for (auto&& obj : objects)
+		env->CallBooleanMethod(arrayList, listAdd, obj);
+	return arrayList;
 }
 
-jobject JNIUtils::createJavaStringArrayList(JNIEnv *env, const std::vector<std::wstring> &strings)
+jobject JNIUtils::createJavaStringArrayList(JNIEnv* env, const std::vector<std::wstring>& strings)
 {
-    jclass arrayListClass = env->FindClass("java/util/ArrayList");
-    jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "<init>", "()V");
-    jobject arrayListObject = env->NewObject(arrayListClass, arrayListConstructor);
-    jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
-    for (const auto &string : strings)
-    {
-        jstring element = env->NewString((jchar *)string.c_str(), string.length());
-        env->CallBooleanMethod(arrayListObject, addMethod, element);
-        env->DeleteLocalRef(element);
-    }
-    return arrayListObject;
+	jclass arrayListClass = env->FindClass("java/util/ArrayList");
+	jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "<init>", "()V");
+	jobject arrayListObject = env->NewObject(arrayListClass, arrayListConstructor);
+	jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z");
+	for (const auto& string : strings)
+	{
+		jstring element = env->NewString((jchar*)string.c_str(), string.length());
+		env->CallBooleanMethod(arrayListObject, addMethod, element);
+		env->DeleteLocalRef(element);
+	}
+	return arrayListObject;
 }

src/android/app/src/main/cpp/JNIUtils.h

@@ -5,139 +5,154 @@
 
 namespace JNIUtils
 {
-extern JavaVM *g_jvm;
+	extern JavaVM* g_jvm;
 
-std::string JStringToString(JNIEnv *env, jstring jstr);
+	std::string JStringToString(JNIEnv* env, jstring jstr);
 
-jobject createJavaStringArrayList(JNIEnv *env, const std::vector<std::string> &stringList);
+	jobject createJavaStringArrayList(JNIEnv* env, const std::vector<std::string>& stringList);
 
-jobject createJavaStringArrayList(JNIEnv *env, const std::vector<std::wstring> &stringList);
+	jobject createJavaStringArrayList(JNIEnv* env, const std::vector<std::wstring>& stringList);
 
-class ScopedJNIENV
-{
-   public:
-    ScopedJNIENV()
-    {
-        jint result = g_jvm->GetEnv((void **)&m_env, JNI_VERSION_1_6);
-        if (result == JNI_EDETACHED)
-        {
-            JavaVMAttachArgs args;
-            args.version = JNI_VERSION_1_6;
-            args.name = nullptr;
-            args.group = nullptr;
-            result = g_jvm->AttachCurrentThread(&m_env, &args);
-            if (result == JNI_OK)
-                m_threadWasAttached = true;
-        }
-    }
+	class ScopedJNIENV {
+	  public:
+		ScopedJNIENV()
+		{
+			jint result = g_jvm->GetEnv((void**)&m_env, JNI_VERSION_1_6);
+			if (result == JNI_EDETACHED)
+			{
+				JavaVMAttachArgs args;
+				args.version = JNI_VERSION_1_6;
+				args.name = nullptr;
+				args.group = nullptr;
+				result = g_jvm->AttachCurrentThread(&m_env, &args);
+				if (result == JNI_OK)
+					m_threadWasAttached = true;
+			}
+		}
 
-    JNIEnv *&operator*() { return m_env; }
+		JNIEnv*& operator*()
+		{
+			return m_env;
+		}
 
-    JNIEnv *operator->() { return m_env; }
+		JNIEnv* operator->()
+		{
+			return m_env;
+		}
 
-    ~ScopedJNIENV()
-    {
-        if (m_threadWasAttached)
-            g_jvm->DetachCurrentThread();
-    }
+		~ScopedJNIENV()
+		{
+			if (m_threadWasAttached)
+				g_jvm->DetachCurrentThread();
+		}
 
-   private:
-    JNIEnv *m_env = nullptr;
-    bool m_threadWasAttached = false;
-};
+	  private:
+		JNIEnv* m_env = nullptr;
+		bool m_threadWasAttached = false;
+	};
 
-class Scopedjobject
-{
-   public:
-    Scopedjobject() = default;
+	class Scopedjobject {
+	  public:
+		Scopedjobject() = default;
 
-    Scopedjobject(Scopedjobject &&other)
-    {
-        this->m_jobject = other.m_jobject;
-        other.m_jobject = nullptr;
-    }
-    void deleteRef()
-    {
-        if (m_jobject)
-        {
-            ScopedJNIENV()->DeleteGlobalRef(m_jobject);
-            m_jobject = nullptr;
-        }
-    }
-    Scopedjobject &operator=(Scopedjobject &&other)
-    {
-        if (this != &other)
-        {
-            deleteRef();
-            m_jobject = other.m_jobject;
-            other.m_jobject = nullptr;
-        }
-        return *this;
-    }
-    jobject &operator*() { return m_jobject; }
+		Scopedjobject(Scopedjobject&& other)
+		{
+			this->m_jobject = other.m_jobject;
+			other.m_jobject = nullptr;
+		}
+		void deleteRef()
+		{
+			if (m_jobject)
+			{
+				ScopedJNIENV()->DeleteGlobalRef(m_jobject);
+				m_jobject = nullptr;
+			}
+		}
+		Scopedjobject& operator=(Scopedjobject&& other)
+		{
+			if (this != &other)
+			{
+				deleteRef();
+				m_jobject = other.m_jobject;
+				other.m_jobject = nullptr;
+			}
+			return *this;
+		}
+		jobject& operator*()
+		{
+			return m_jobject;
+		}
 
-    Scopedjobject(jobject obj)
-    {
-        if (obj)
-            m_jobject = ScopedJNIENV()->NewGlobalRef(obj);
-    }
+		Scopedjobject(jobject obj)
+		{
+			if (obj)
+				m_jobject = ScopedJNIENV()->NewGlobalRef(obj);
+		}
 
-    ~Scopedjobject()
-    {
-        deleteRef();
-    }
+		~Scopedjobject()
+		{
+			deleteRef();
+		}
 
-    bool isValid() const { return m_jobject; }
+		bool isValid() const
+		{
+			return m_jobject;
+		}
 
-   private:
-    jobject m_jobject = nullptr;
-};
+	  private:
+		jobject m_jobject = nullptr;
+	};
 
-class Scopedjclass
-{
-   public:
-    Scopedjclass() = default;
+	class Scopedjclass {
+	  public:
+		Scopedjclass() = default;
 
-    Scopedjclass(Scopedjclass &&other)
-    {
-        this->m_jclass = other.m_jclass;
-        other.m_jclass = nullptr;
-    }
+		Scopedjclass(Scopedjclass&& other)
+		{
+			this->m_jclass = other.m_jclass;
+			other.m_jclass = nullptr;
+		}
 
-    Scopedjclass &operator=(Scopedjclass &&other)
-    {
-        if (this != &other)
-        {
-            if (m_jclass)
-                ScopedJNIENV()->DeleteGlobalRef(m_jclass);
-            m_jclass = other.m_jclass;
-            other.m_jclass = nullptr;
-        }
-        return *this;
-    }
+		Scopedjclass& operator=(Scopedjclass&& other)
+		{
+			if (this != &other)
+			{
+				if (m_jclass)
+					ScopedJNIENV()->DeleteGlobalRef(m_jclass);
+				m_jclass = other.m_jclass;
+				other.m_jclass = nullptr;
+			}
+			return *this;
+		}
 
-    Scopedjclass(const std::string &className)
-    {
-        ScopedJNIENV scopedEnv;
-        jobject tempObj = scopedEnv->FindClass(className.c_str());
-        m_jclass = static_cast<jclass>(scopedEnv->NewGlobalRef(tempObj));
-        scopedEnv->DeleteLocalRef(tempObj);
-    }
+		Scopedjclass(const std::string& className)
+		{
+			ScopedJNIENV scopedEnv;
+			jobject tempObj = scopedEnv->FindClass(className.c_str());
+			m_jclass = static_cast<jclass>(scopedEnv->NewGlobalRef(tempObj));
+			scopedEnv->DeleteLocalRef(tempObj);
+		}
 
-    ~Scopedjclass()
-    {
-        if (m_jclass)
-            ScopedJNIENV()->DeleteGlobalRef(m_jclass);
-    }
+		~Scopedjclass()
+		{
+			if (m_jclass)
+				ScopedJNIENV()->DeleteGlobalRef(m_jclass);
+		}
 
-    bool isValid() const { return m_jclass; }
+		bool isValid() const
+		{
+			return m_jclass;
+		}
 
-    jclass &operator*() { return m_jclass; }
+		jclass& operator*()
+		{
+			return m_jclass;
+		}
 
-   private:
-    jclass m_jclass = nullptr;
-};
+	  private:
+		jclass m_jclass = nullptr;
+	};
 
-Scopedjobject getEnumValue(JNIEnv *env, const std::string &enumClassName, const std::string &enumName);
-jobject createArrayList(JNIEnv *env, const std::vector<jobject> &objects);
-}  // namespace JNIUtils
+	Scopedjobject getEnumValue(JNIEnv* env, const std::string& enumClassName, const std::string& enumName);
+	jobject createArrayList(JNIEnv* env, const std::vector<jobject>& objects);
+} // namespace JNIUtils

src/android/app/src/main/cpp/Utils.cpp

@@ -15,9 +15,9 @@ void createCemuDirectories()
 
 		const auto usrFolder = fs::path(mlc).append(L"usr");
 		fs::create_directories(usrFolder);
-		fs::create_directories(fs::path(usrFolder).append("title/00050000"));  // base
-		fs::create_directories(fs::path(usrFolder).append("title/0005000c"));  // dlc
-		fs::create_directories(fs::path(usrFolder).append("title/0005000e"));  // update
+		fs::create_directories(fs::path(usrFolder).append("title/00050000")); // base
+		fs::create_directories(fs::path(usrFolder).append("title/0005000c")); // dlc
+		fs::create_directories(fs::path(usrFolder).append("title/0005000e")); // update
 
 		// Mii Maker save folders {0x500101004A000, 0x500101004A100, 0x500101004A200},
 		fs::create_directories(fs::path(mlc).append(L"usr/save/00050010/1004a000/user/common/db"));
@@ -34,8 +34,8 @@ void createCemuDirectories()
 			std::ofstream file(langFile);
 			if (file.is_open())
 			{
-				const char *langStrings[] = {"ja", "en", "fr", "de", "it", "es", "zh", "ko", "nl", "pt", "ru", "zh"};
-				for (const char *lang : langStrings)
+				const char* langStrings[] = {"ja", "en", "fr", "de", "it", "es", "zh", "ko", "nl", "pt", "ru", "zh"};
+				for (const char* lang : langStrings)
 					file << fmt::format(R"("{}",)", lang) << std::endl;
 
 				file.flush();
@@ -49,7 +49,7 @@ void createCemuDirectories()
 			std::ofstream file(countryFile);
 			for (sint32 i = 0; i < 201; i++)
 			{
-				const char *countryCode = NCrypto::GetCountryAsString(i);
+				const char* countryCode = NCrypto::GetCountryAsString(i);
 				if (boost::iequals(countryCode, "NN"))
 					file << "NULL," << std::endl;
 				else
@@ -58,8 +58,7 @@ void createCemuDirectories()
 			file.flush();
 			file.close();
 		}
-	}
-	catch (const std::exception &ex)
+	} catch (const std::exception& ex)
 	{
 		exit(0);
 	}
@@ -74,8 +73,7 @@ void createCemuDirectories()
 		const auto memorySearcherFolder = ActiveSettings::GetUserDataPath(L"memorySearcher").generic_wstring();
 		if (!fs::exists(memorySearcherFolder))
 			fs::create_directories(memorySearcherFolder);
-	}
-	catch (const std::exception &ex)
+	} catch (const std::exception& ex)
 	{
 		exit(0);
 	}

src/android/app/src/main/cpp/native-lib.cpp

@@ -6,32 +6,32 @@
 
 EmulationState s_emulationState;
 
-extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, [[maybe_unused]] void *reserved)
+extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, [[maybe_unused]] void* reserved)
 {
 	JNIUtils::g_jvm = vm;
 	return JNI_VERSION_1_6;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setSurface(JNIEnv *env, [[maybe_unused]] jclass clazz, jobject surface, jboolean is_main_canvas)
+Java_info_cemu_Cemu_NativeLibrary_setSurface(JNIEnv* env, [[maybe_unused]] jclass clazz, jobject surface, jboolean is_main_canvas)
 {
 	s_emulationState.setSurface(env, surface, is_main_canvas);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setSurfaceSize([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint width, jint height, jboolean is_main_canvas)
+Java_info_cemu_Cemu_NativeLibrary_setSurfaceSize([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint width, jint height, jboolean is_main_canvas)
 {
 	s_emulationState.setSurfaceSize(width, height, is_main_canvas);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_startGame([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jlong title_id)
+Java_info_cemu_Cemu_NativeLibrary_startGame([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jlong title_id)
 {
-	s_emulationState.startGame(*reinterpret_cast<TitleId *>(&title_id));
+	s_emulationState.startGame(*reinterpret_cast<TitleId*>(&title_id));
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setGameTitleLoadedCallback(JNIEnv *env, [[maybe_unused]] jclass clazz, jobject game_title_loaded_callback)
+Java_info_cemu_Cemu_NativeLibrary_setGameTitleLoadedCallback(JNIEnv* env, [[maybe_unused]] jclass clazz, jobject game_title_loaded_callback)
 {
 	jclass gameTitleLoadedCallbackClass = env->GetObjectClass(game_title_loaded_callback);
 	jmethodID onGameTitleLoadedMID = env->GetMethodID(gameTitleLoadedCallbackClass, "onGameTitleLoaded", "(JLjava/lang/String;)V");
@@ -40,7 +40,7 @@ Java_info_cemu_Cemu_NativeLibrary_setGameTitleLoadedCallback(JNIEnv *env, [[mayb
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setGameIconLoadedCallback(JNIEnv *env, [[maybe_unused]] jclass clazz, jobject game_icon_loaded_callback)
+Java_info_cemu_Cemu_NativeLibrary_setGameIconLoadedCallback(JNIEnv* env, [[maybe_unused]] jclass clazz, jobject game_icon_loaded_callback)
 {
 	jclass gameIconLoadedCallbackClass = env->GetObjectClass(game_icon_loaded_callback);
 	jmethodID gameIconLoadedMID = env->GetMethodID(gameIconLoadedCallbackClass, "onGameIconLoaded", "(J[III)V");
@@ -48,18 +48,18 @@ Java_info_cemu_Cemu_NativeLibrary_setGameIconLoadedCallback(JNIEnv *env, [[maybe
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_requestGameIcon([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jlong title_id)
+Java_info_cemu_Cemu_NativeLibrary_requestGameIcon([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jlong title_id)
 {
-	s_emulationState.requestGameIcon(*reinterpret_cast<TitleId *>(&title_id));
+	s_emulationState.requestGameIcon(*reinterpret_cast<TitleId*>(&title_id));
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_reloadGameTitles([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_reloadGameTitles([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	s_emulationState.reloadGameTitles();
 }
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_initializeActiveSettings(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring data_path, jstring cache_path)
+Java_info_cemu_Cemu_NativeLibrary_initializeActiveSettings(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring data_path, jstring cache_path)
 {
 	std::string dataPath = JNIUtils::JStringToString(env, data_path);
 	std::string cachePath = JNIUtils::JStringToString(env, cache_path);
@@ -67,45 +67,45 @@ Java_info_cemu_Cemu_NativeLibrary_initializeActiveSettings(JNIEnv *env, [[maybe_
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_initializeEmulation([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_initializeEmulation([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	s_emulationState.initializeEmulation();
 }
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_initializerRenderer([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_initializerRenderer([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	s_emulationState.initializeRenderer();
 }
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_initializeRendererSurface([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
+Java_info_cemu_Cemu_NativeLibrary_initializeRendererSurface([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
 {
 	s_emulationState.initializeRenderSurface(is_main_canvas);
 }
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setDPI([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jfloat dpi)
+Java_info_cemu_Cemu_NativeLibrary_setDPI([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jfloat dpi)
 {
 	s_emulationState.setDPI(dpi);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_clearSurface([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
+Java_info_cemu_Cemu_NativeLibrary_clearSurface([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
 {
 	s_emulationState.clearSurface(is_main_canvas);
 }
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_recreateRenderSurface([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
+Java_info_cemu_Cemu_NativeLibrary_recreateRenderSurface([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean is_main_canvas)
 {
 	s_emulationState.notifySurfaceChanged(is_main_canvas);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_addGamePath(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring uri)
+Java_info_cemu_Cemu_NativeLibrary_addGamePath(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring uri)
 {
 	s_emulationState.addGamePath(JNIUtils::JStringToString(env, uri));
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_onNativeKey(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint key, jboolean is_pressed)
+Java_info_cemu_Cemu_NativeLibrary_onNativeKey(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint key, jboolean is_pressed)
 {
 	auto deviceDescriptor = JNIUtils::JStringToString(env, device_descriptor);
 	auto deviceName = JNIUtils::JStringToString(env, device_name);
@@ -113,7 +113,7 @@ Java_info_cemu_Cemu_NativeLibrary_onNativeKey(JNIEnv *env, [[maybe_unused]] jcla
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_onNativeAxis(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint axis, jfloat value)
+Java_info_cemu_Cemu_NativeLibrary_onNativeAxis(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint axis, jfloat value)
 {
 	auto deviceDescriptor = JNIUtils::JStringToString(env, device_descriptor);
 	auto deviceName = JNIUtils::JStringToString(env, device_name);
@@ -121,37 +121,37 @@ Java_info_cemu_Cemu_NativeLibrary_onNativeAxis(JNIEnv *env, [[maybe_unused]] jcl
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setControllerType([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint index, jint emulated_controller_type)
+Java_info_cemu_Cemu_NativeLibrary_setControllerType([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint index, jint emulated_controller_type)
 {
 	s_emulationState.setEmulatedControllerType(index, static_cast<EmulatedController::Type>(emulated_controller_type));
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getControllerType([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint index)
+Java_info_cemu_Cemu_NativeLibrary_getControllerType([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint index)
 {
 	return s_emulationState.getEmulatedControllerType(index);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getWPADControllersCount([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_getWPADControllersCount([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	return s_emulationState.getWPADControllersCount();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getVPADControllersCount([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_getVPADControllersCount([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	return s_emulationState.getVPADControllersCount();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jboolean JNICALL
-Java_info_cemu_Cemu_NativeLibrary_isControllerDisabled([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint index)
+Java_info_cemu_Cemu_NativeLibrary_isControllerDisabled([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint index)
 {
 	return s_emulationState.isEmulatedControllerDisabled(index);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setControllerMapping(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint index, jint mapping_id, jint button_id)
+Java_info_cemu_Cemu_NativeLibrary_setControllerMapping(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint index, jint mapping_id, jint button_id)
 {
 	auto deviceName = JNIUtils::JStringToString(env, device_name);
 	auto deviceDescriptor = JNIUtils::JStringToString(env, device_descriptor);
@@ -159,20 +159,20 @@ Java_info_cemu_Cemu_NativeLibrary_setControllerMapping(JNIEnv *env, [[maybe_unus
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jstring JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getControllerMapping(JNIEnv *env, [[maybe_unused]] jclass clazz, jint index, jint mapping_id)
+Java_info_cemu_Cemu_NativeLibrary_getControllerMapping(JNIEnv* env, [[maybe_unused]] jclass clazz, jint index, jint mapping_id)
 {
 	auto mapping = s_emulationState.getEmulatedControllerMapping(index, mapping_id);
 	return env->NewStringUTF(mapping.value_or("").c_str());
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_clearControllerMapping([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint index, jint mapping_id)
+Java_info_cemu_Cemu_NativeLibrary_clearControllerMapping([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint index, jint mapping_id)
 {
 	s_emulationState.clearEmulatedControllerMapping(index, mapping_id);
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jobject JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getControllerMappings(JNIEnv *env, [[maybe_unused]] jclass clazz, jint index)
+Java_info_cemu_Cemu_NativeLibrary_getControllerMappings(JNIEnv* env, [[maybe_unused]] jclass clazz, jint index)
 {
 	jclass hashMapClass = env->FindClass("java/util/HashMap");
 	jmethodID hashMapConstructor = env->GetMethodID(hashMapClass, "<init>", "()V");
@@ -181,7 +181,7 @@ Java_info_cemu_Cemu_NativeLibrary_getControllerMappings(JNIEnv *env, [[maybe_unu
 	jmethodID integerConstructor = env->GetMethodID(integerClass, "<init>", "(I)V");
 	jobject hashMapObj = env->NewObject(hashMapClass, hashMapConstructor);
 	auto mappings = s_emulationState.getEmulatedControllerMappings(index);
-	for (const auto &pair : mappings)
+	for (const auto& pair : mappings)
 	{
 		jint key = pair.first;
 		jstring buttonName = env->NewStringUTF(pair.second.c_str());
@@ -192,7 +192,7 @@ Java_info_cemu_Cemu_NativeLibrary_getControllerMappings(JNIEnv *env, [[maybe_unu
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_onKeyEvent(JNIEnv *env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint key_code, jboolean is_pressed)
+Java_info_cemu_Cemu_NativeLibrary_onKeyEvent(JNIEnv* env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint key_code, jboolean is_pressed)
 {
 	auto deviceDescriptor = JNIUtils::JStringToString(env, device_descriptor);
 	auto deviceName = JNIUtils::JStringToString(env, device_name);
@@ -200,7 +200,7 @@ Java_info_cemu_Cemu_NativeLibrary_onKeyEvent(JNIEnv *env, [[maybe_unused]] jclas
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_onAxisEvent([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint axis_code, jfloat value)
+Java_info_cemu_Cemu_NativeLibrary_onAxisEvent([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jstring device_descriptor, jstring device_name, jint axis_code, jfloat value)
 {
 	auto deviceDescriptor = JNIUtils::JStringToString(env, device_descriptor);
 	auto deviceName = JNIUtils::JStringToString(env, device_name);
@@ -208,55 +208,55 @@ Java_info_cemu_Cemu_NativeLibrary_onAxisEvent([[maybe_unused]] JNIEnv *env, [[ma
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jboolean JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getAsyncShaderCompile([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_getAsyncShaderCompile([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	return g_config.data().async_compile;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setAsyncShaderCompile([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean enabled)
+Java_info_cemu_Cemu_NativeLibrary_setAsyncShaderCompile([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean enabled)
 {
 	g_config.data().async_compile = enabled;
 	g_config.Save();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getVSyncMode([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_getVSyncMode([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	return g_config.data().vsync;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setVSyncMode([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint vsync_mode)
+Java_info_cemu_Cemu_NativeLibrary_setVSyncMode([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint vsync_mode)
 {
 	g_config.data().vsync = vsync_mode;
 	g_config.Save();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jboolean JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getAccurateBarriers([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz)
+Java_info_cemu_Cemu_NativeLibrary_getAccurateBarriers([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz)
 {
 	return g_config.data().vk_accurate_barriers;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setAccurateBarriers([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean enabled)
+Java_info_cemu_Cemu_NativeLibrary_setAccurateBarriers([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean enabled)
 {
 	g_config.data().vk_accurate_barriers = enabled;
 	g_config.Save();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jboolean JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceEnabled([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceEnabled([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean tv)
 {
-	const auto &device = tv ? g_config.data().tv_device : g_config.data().pad_device;
+	const auto& device = tv ? g_config.data().tv_device : g_config.data().pad_device;
 	return !device.empty();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceEnabled([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean enabled, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceEnabled([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean enabled, jboolean tv)
 {
-	auto &device = tv ? g_config.data().tv_device : g_config.data().pad_device;
+	auto& device = tv ? g_config.data().tv_device : g_config.data().pad_device;
 	if (enabled)
 		device = L"Default";
 	else
@@ -265,31 +265,31 @@ Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceEnabled([[maybe_unused]] JNIEnv
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceChannels([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceChannels([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean tv)
 {
-	const auto &deviceChannels = tv ? g_config.data().tv_channels : g_config.data().pad_channels;
+	const auto& deviceChannels = tv ? g_config.data().tv_channels : g_config.data().pad_channels;
 	return deviceChannels;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceChannels([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint channels, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceChannels([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint channels, jboolean tv)
 {
-	auto &deviceChannels = tv ? g_config.data().tv_channels : g_config.data().pad_channels;
+	auto& deviceChannels = tv ? g_config.data().tv_channels : g_config.data().pad_channels;
 	deviceChannels = static_cast<AudioChannels>(channels);
 	g_config.Save();
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT jint JNICALL
-Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceVolume([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_getAudioDeviceVolume([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jboolean tv)
 {
-	const auto &deviceVolume = tv ? g_config.data().tv_volume : g_config.data().pad_volume;
+	const auto& deviceVolume = tv ? g_config.data().tv_volume : g_config.data().pad_volume;
 	return deviceVolume;
 }
 
 extern "C" [[maybe_unused]] JNIEXPORT void JNICALL
-Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceVolume([[maybe_unused]] JNIEnv *env, [[maybe_unused]] jclass clazz, jint volume, jboolean tv)
+Java_info_cemu_Cemu_NativeLibrary_setAudioDeviceVolume([[maybe_unused]] JNIEnv* env, [[maybe_unused]] jclass clazz, jint volume, jboolean tv)
 {
-	auto &deviceVolume = tv ? g_config.data().tv_volume : g_config.data().pad_volume;
+	auto& deviceVolume = tv ? g_config.data().tv_volume : g_config.data().pad_volume;
 	deviceVolume = volume;
 	g_config.Save();
 }