130 lines
5.3 KiB
C++
130 lines
5.3 KiB
C++
/**
|
|
******************************************************************************
|
|
* Xenia : Xbox 360 Emulator Research Project *
|
|
******************************************************************************
|
|
* Copyright 2021 Ben Vanik. All rights reserved. *
|
|
* Released under the BSD license - see LICENSE in the root for more details. *
|
|
******************************************************************************
|
|
*/
|
|
|
|
#ifndef XENIA_UI_WINDOWED_APP_H_
|
|
#define XENIA_UI_WINDOWED_APP_H_
|
|
|
|
#include <cstddef>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "xenia/base/platform.h"
|
|
#include "xenia/ui/windowed_app_context.h"
|
|
|
|
#if XE_PLATFORM_ANDROID
|
|
#include <android/native_activity.h>
|
|
|
|
#include "xenia/ui/windowed_app_context_android.h"
|
|
#endif
|
|
|
|
namespace xe {
|
|
namespace ui {
|
|
|
|
// Interface between the platform's entry points (in the main, UI, thread that
|
|
// also runs the message loop) and the app that implements it.
|
|
class WindowedApp {
|
|
public:
|
|
// WindowedApps are expected to provide a static creation function, for
|
|
// creating an instance of the class (which may be called before
|
|
// initialization of platform-specific parts, should preferably be as simple
|
|
// as possible).
|
|
|
|
WindowedApp(const WindowedApp& app) = delete;
|
|
WindowedApp& operator=(const WindowedApp& app) = delete;
|
|
virtual ~WindowedApp() = default;
|
|
|
|
WindowedAppContext& app_context() const { return app_context_; }
|
|
|
|
// Same as the executable (project), xenia-library-app.
|
|
const std::string& GetName() const { return name_; }
|
|
const std::string& GetPositionalOptionsUsage() const {
|
|
return positional_options_usage_;
|
|
}
|
|
const std::vector<std::string>& GetPositionalOptions() const {
|
|
return positional_options_;
|
|
}
|
|
|
|
// Called once before receiving other lifecycle callback invocations. Cvars
|
|
// will be initialized with the launch arguments. Returns whether the app has
|
|
// been initialized successfully (otherwise platform-specific code must call
|
|
// OnDestroy and refuse to continue running the app).
|
|
virtual bool OnInitialize() = 0;
|
|
// See OnDestroy for more info.
|
|
void InvokeOnDestroy() {
|
|
// For safety and convenience of referencing objects owned by the app in
|
|
// pending functions queued in or after OnInitialize, make sure they are
|
|
// executed before telling the app that destruction needs to happen.
|
|
app_context().ExecutePendingFunctionsFromUIThread();
|
|
OnDestroy();
|
|
}
|
|
|
|
protected:
|
|
// Positional options should be initialized in the constructor if needed.
|
|
// Cvars will not have been initialized with the arguments at the moment of
|
|
// construction (as the result depends on construction).
|
|
explicit WindowedApp(
|
|
WindowedAppContext& app_context, const std::string_view name,
|
|
const std::string_view positional_options_usage = std::string_view())
|
|
: app_context_(app_context),
|
|
name_(name),
|
|
positional_options_usage_(positional_options_usage) {}
|
|
|
|
// For calling from the constructor.
|
|
void AddPositionalOption(const std::string_view option) {
|
|
positional_options_.emplace_back(option);
|
|
}
|
|
|
|
// OnDestroy entry point may be called (through InvokeOnDestroy) by the
|
|
// platform-specific lifecycle interface at request of either the app itself
|
|
// or the OS - thus should be possible for the lifecycle interface to call at
|
|
// any moment (not from inside other lifecycle callbacks though). The app will
|
|
// also be destroyed when that happens, so the destructor will also be called
|
|
// (but this is more safe with respect to exceptions). This is only guaranteed
|
|
// to be called if OnInitialize has already happened (successfully or not) -
|
|
// in case of an error before initialization, the destructor may be called
|
|
// alone as well. Context's pending functions will be executed before the
|
|
// call, so it's safe to destroy dependencies of them here (though it may
|
|
// still be possible to add more pending functions here depending on whether
|
|
// the context was explicitly shut down before this is invoked).
|
|
virtual void OnDestroy() {}
|
|
|
|
private:
|
|
WindowedAppContext& app_context_;
|
|
|
|
std::string name_;
|
|
std::string positional_options_usage_;
|
|
std::vector<std::string> positional_options_;
|
|
};
|
|
|
|
#if XE_PLATFORM_ANDROID
|
|
// Multiple apps in a single library. ANativeActivity_onCreate chosen via
|
|
// android.app.func_name of the NativeActivity of each app.
|
|
#define XE_DEFINE_WINDOWED_APP(export_name, creator) \
|
|
__attribute__((visibility("default"))) extern "C" void export_name( \
|
|
ANativeActivity* activity, void* saved_state, size_t saved_state_size) { \
|
|
xe::ui::AndroidWindowedAppContext::StartAppOnNativeActivityCreate( \
|
|
activity, saved_state, saved_state_size, creator); \
|
|
}
|
|
#else
|
|
// Separate executables for each app.
|
|
std::unique_ptr<WindowedApp> (*GetWindowedAppCreator())(
|
|
WindowedAppContext& app_context);
|
|
#define XE_DEFINE_WINDOWED_APP(export_name, creator) \
|
|
std::unique_ptr<xe::ui::WindowedApp> (*xe::ui::GetWindowedAppCreator())( \
|
|
xe::ui::WindowedAppContext & app_context) { \
|
|
return creator; \
|
|
}
|
|
#endif
|
|
|
|
} // namespace ui
|
|
} // namespace xe
|
|
|
|
#endif // XENIA_UI_WINDOWED_APP_H_
|