ppsspp/Common/System/Request.h

#pragma once

#include <atomic>
#include <vector>
#include <deque>
#include <mutex>
#include <map>
#include <functional>
#include <string_view>

#include "Common/System/System.h"
#include "Common/File/Path.h"

class Path;

typedef std::function<void(std::string_view responseString, int responseValue)> RequestCallback;
typedef std::function<void(int responseValue)> RequestFailedCallback;

typedef int RequesterToken;

#define NO_REQUESTER_TOKEN -1
#define NON_EPHEMERAL_TOKEN -2

// Used on Android for file browsing requests and similar.
#define NO_ACTIVITY_AVAILABLE 1

// Platforms often have to process requests asynchronously, on wildly different threads,
// and then somehow pass a response back to the main thread (especially Android...)
// This acts as bridge and buffer.
// However - the actual request is performed on the current thread, it's the callbacks that are "made threadsafe"
// by running them on the main thread. So beware in your implementations!
class RequestManager {
public:
	// These requests are to be handled by platform implementations.
	// The callback you pass in will be called on the main thread later.
	// Params are at the end since it's the part most likely to recieve additions in the future,
	// now that we have both callbacks.
	// Pointers can be passed through param3 and param4 if needed, by casting.
	bool MakeSystemRequest(SystemRequestType type, RequesterToken token, RequestCallback callback, RequestFailedCallback failedCallback, std::string_view param1, std::string_view param2, int64_t param3, int64_t param4 = 0);

	// Called by the platform implementation, when it's finished with a request.
	void PostSystemSuccess(int requestId, std::string_view responseString, int responseValue = 0);
	void PostSystemFailure(int requestId, int responseValue = 0);

	// This must be called every frame from the beginning of NativeFrame().
	// This will call the callback of any finished requests.
	void ProcessRequests();

	RequesterToken GenerateRequesterToken() {
		int token = tokenGen_++;
		return token;
	}

	void ForgetRequestsWithToken(RequesterToken token);

	// Unclear if we need this...
	void Clear();

private:
	struct CallbackPair {
		RequestCallback callback;
		RequestFailedCallback failedCallback;
		RequesterToken token;
	};

	std::map<int, CallbackPair> callbackMap_;
	std::mutex callbackMutex_;

	// A finished request, waiting for ProcessRequests to call its callback.
	struct PendingResponse {
		bool success;
		std::string responseString;
		int responseValue;  // can have error codes for example.
		RequestCallback callback;
		RequestFailedCallback failedCallback;
		RequesterToken token;
	};

	// Let's start at 10 to get a recognizably valid ID in logs.
	// Atomic since requests are made from several threads (the CPU thread for the OSK and the microphone).
	std::atomic<int> idCounter_{ 10 };
	std::deque<PendingResponse> pendingResponses_;
	std::mutex responseMutex_;

	std::atomic<RequesterToken> tokenGen_{ 20000 };
};

const char *RequestTypeAsString(SystemRequestType type);

extern RequestManager g_requestManager;

// Wrappers for easy requests.
// NOTE: Semantics have changed - this no longer calls the callback on cancellation, instead you
// can specify a different callback for that.
inline void System_InputBoxGetString(RequesterToken token, std::string_view title, std::string_view defaultValue, bool passwordMasking, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::INPUT_TEXT_MODAL, token, callback, failedCallback, title, defaultValue, passwordMasking ? 1 : 0);
}

// This one will pop up a special image browser if available. You can also pick
// images with the file browser below. If you provide savePath, iOS will be able to
// convert from HEIC as needed and then save to that path. If this happens, the intParam will
// be set to 1. Other backends will probably ignore it and set the intParam to 0.
inline void System_BrowseForImage(RequesterToken token, std::string_view title, Path savePath, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::BROWSE_FOR_IMAGE, token, callback, failedCallback, title, savePath.ToString(), 0);
}

enum class BrowseFileType {
	BOOTABLE,
	SAVE_STATE,
	IMAGE,
	INI,
	DB,
	SOUND_EFFECT,
	ZIP,
	SYMBOL_MAP,
	SYMBOL_MAP_NOCASH,
	ATRAC3,
	ANY,
};

inline void System_BrowseForFile(RequesterToken token, std::string_view title, BrowseFileType type, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::BROWSE_FOR_FILE, token, callback, failedCallback, title, "", (int)type);
}

inline void System_BrowseForFileSave(RequesterToken token, std::string_view title, std::string_view defaultFilename, BrowseFileType type, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::BROWSE_FOR_FILE_SAVE, token, callback, failedCallback, title, defaultFilename, (int)type);
}

void System_BrowseForFolder(RequesterToken token, std::string_view title, const Path &initialPath, RequestCallback callback, RequestFailedCallback failedCallback = nullptr);

// The returned string is username + '\n' + password.
inline void System_AskUsernamePassword(RequesterToken token, std::string_view title, std::string_view defaultUsername, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::ASK_USERNAME_PASSWORD, token, callback, failedCallback, title, defaultUsername, 0);
}

inline void System_CopyStringToClipboard(std::string_view string) {
	g_requestManager.MakeSystemRequest(SystemRequestType::COPY_TO_CLIPBOARD, NO_REQUESTER_TOKEN, nullptr, nullptr, string, "", 0);
}

inline void System_ExitApp() {
	g_requestManager.MakeSystemRequest(SystemRequestType::EXIT_APP, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", 0);
}

inline void System_RestartApp(std::string_view params) {
	g_requestManager.MakeSystemRequest(SystemRequestType::RESTART_APP, NO_REQUESTER_TOKEN, nullptr, nullptr, params, "", 0);
}

inline void System_RecreateActivity() {
	g_requestManager.MakeSystemRequest(SystemRequestType::RECREATE_ACTIVITY, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", 0);
}

inline void System_ApplyFullscreenState() {
	g_requestManager.MakeSystemRequest(SystemRequestType::APPLY_FULLSCREEN_STATE, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", 0);
}

inline void System_GraphicsBackendFailedAlert(std::string_view param) {
	g_requestManager.MakeSystemRequest(SystemRequestType::GRAPHICS_BACKEND_FAILED_ALERT, NO_REQUESTER_TOKEN, nullptr, nullptr, param, "", 0);
}

inline void System_CameraCommand(std::string_view command) {
	g_requestManager.MakeSystemRequest(SystemRequestType::CAMERA_COMMAND, NO_REQUESTER_TOKEN, nullptr, nullptr, command, "", 0);
}

inline void System_GPSCommand(std::string_view command) {
	g_requestManager.MakeSystemRequest(SystemRequestType::GPS_COMMAND, NO_REQUESTER_TOKEN, nullptr, nullptr, command, "", 0);
}

inline void System_InfraredCommand(std::string_view command) {
	g_requestManager.MakeSystemRequest(SystemRequestType::INFRARED_COMMAND, NO_REQUESTER_TOKEN, nullptr, nullptr, command, "", 0);
}

inline void System_MicrophoneCommand(std::string_view command) {
	g_requestManager.MakeSystemRequest(SystemRequestType::MICROPHONE_COMMAND, NO_REQUESTER_TOKEN, nullptr, nullptr, command, "", 0);
}

inline void System_ShareText(std::string_view text) {
	g_requestManager.MakeSystemRequest(SystemRequestType::SHARE_TEXT, NO_REQUESTER_TOKEN, nullptr, nullptr, text, "", 0);
}

// Offers a file to other apps (mail, chat, cloud storage) through the system's share sheet, if
// SYSPROP_SUPPORTS_SHARE_FILE. With an empty mimeType, it's guessed from the extension.
inline void System_ShareFile(const Path &path, std::string_view mimeType = "") {
	g_requestManager.MakeSystemRequest(SystemRequestType::SHARE_FILE, NO_REQUESTER_TOKEN, nullptr, nullptr, path.ToString(), mimeType, 0);
}

// Talking to other devices on the local network (in either direction) needs a runtime permission on
// Android 17+. Asks for it unless it's granted or already being asked for. Returns true if granted.
inline bool System_RequestLocalNetworkPermission() {
	PermissionStatus status = System_GetPermissionStatus(SYSTEM_PERMISSION_LOCAL_NETWORK);
	if (status == PERMISSION_STATUS_GRANTED) {
		return true;
	}
	if (status != PERMISSION_STATUS_PENDING) {
		System_AskForPermission(SYSTEM_PERMISSION_LOCAL_NETWORK);
	}
	return false;
}

// TEXT_GOTFOCUS/TEXT_LOSTFOCUS (and POPUP_CLOSED) sent through here count as the regular UI's use of text input.
void System_NotifyUIEvent(UIEventNotification notification);

// Several users can want text input at the same time (for example type-to-search under the imgui debugger).
// The platform only gets TEXT_LOSTFOCUS once none of them does.
enum class TextInputUser {
	UI,
	ImDebugger,
	COUNT,
};
void System_SetTextInputWanted(TextInputUser user, bool wanted);

// Keeps the soft keyboard up (typing as key and char events) until called with false. With keepAfterAppSwitch,
// it comes back after switching to another app and back, otherwise the platform drops it then. When the platform
// closes it, it posts UIMessage::SOFT_KEYBOARD_HIDDEN. Only Android implements this so far, though other platforms
// with SYSPROP_KEYBOARD_IS_SOFT should.
inline void System_SetSoftKeyboardForced(bool forced, bool keepAfterAppSwitch) {
	g_requestManager.MakeSystemRequest(SystemRequestType::SET_SOFT_KEYBOARD_FORCED, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", (int64_t)forced, (int64_t)keepAfterAppSwitch);
}

inline void System_SetKeepScreenBright(bool keepScreenBright) {
	g_requestManager.MakeSystemRequest(SystemRequestType::SET_KEEP_SCREEN_BRIGHT, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", (int64_t)keepScreenBright);
}

inline void System_SetWindowTitle(std::string_view param) {
	g_requestManager.MakeSystemRequest(SystemRequestType::SET_WINDOW_TITLE, NO_REQUESTER_TOKEN, nullptr, nullptr, param, "", 0);
}


inline void System_IAPRestorePurchases(RequesterToken token, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::IAP_RESTORE_PURCHASES, token, callback, failedCallback, "", "", 0);
}

inline void System_IAPMakePurchase(RequesterToken token, std::string_view productID, RequestCallback callback, RequestFailedCallback failedCallback = nullptr) {
	g_requestManager.MakeSystemRequest(SystemRequestType::IAP_MAKE_PURCHASE, token, callback, failedCallback, productID, "", 0);
}

inline void System_OpenDisplaySettings() {
	g_requestManager.MakeSystemRequest(SystemRequestType::OPEN_DISPLAY_SETTINGS, NO_REQUESTER_TOKEN, nullptr, nullptr, "", "", 0);
}

void System_MoveToTrash(const Path &path);
void System_RunCallbackInWndProc(void (*callback)(void *, void *), void *userdata);

// Non-inline to avoid including Path.h
void System_CreateGameShortcut(const Path &path, std::string_view title);
void System_ShowFileInFolder(const Path &path);