Address remaining feedback on #106709

Address #106709 (comment)

Author: m4gr3d

platform/android/display_server_android.cpp

@@ -588,13 +588,21 @@ bool DisplayServerAndroid::window_is_maximize_allowed(DisplayServer::WindowID p_
 }
 
 void DisplayServerAndroid::window_set_flag(DisplayServer::WindowFlags p_flag, bool p_enabled, DisplayServer::WindowID p_window) {
-	// Not supported on Android.
+	ERR_FAIL_COND(p_window != MAIN_WINDOW_ID);
+	switch (p_flag) {
+		case WindowFlags::WINDOW_FLAG_TRANSPARENT:
+			if (is_window_transparency_available()) {
+				OS_Android::get_singleton()->get_godot_java()->set_window_flag(p_flag, p_enabled);
+			}
+			break;
+	}
 }
 
 bool DisplayServerAndroid::window_get_flag(DisplayServer::WindowFlags p_flag, DisplayServer::WindowID p_window) const {
+	ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, false);
 	switch (p_flag) {
 		case WindowFlags::WINDOW_FLAG_TRANSPARENT:
-			return is_window_transparency_available();
+			return is_window_transparency_available() && OS_Android::get_singleton()->get_godot_java()->get_window_flag(p_flag);
 
 		default:
 			return false;

platform/android/export/export_plugin.cpp

@@ -1055,7 +1055,7 @@ void EditorExportPlatformAndroid::_write_tmp_manifest(const Ref<EditorExportPres
 	store_string_at_path(manifest_path, manifest_text);
 }
 
-bool EditorExportPlatformAndroid::_should_be_transparent(const Ref<EditorExportPreset> &p_preset) const {
+bool EditorExportPlatformAndroid::_is_transparency_allowed(const Ref<EditorExportPreset> &p_preset) const {
 	return (bool)get_project_setting(p_preset, "display/window/per_pixel_transparency/allowed");
 }
 
@@ -1067,22 +1067,22 @@ void EditorExportPlatformAndroid::_fix_themes_xml(const Ref<EditorExportPreset>
 		return;
 	}
 
-	bool should_be_transparent = _should_be_transparent(p_preset);
+	bool transparency_allowed = _is_transparency_allowed(p_preset);
 
 	// Default/Reserved theme attributes.
 	Dictionary main_theme_attributes;
 	main_theme_attributes["android:windowDrawsSystemBarBackgrounds"] = "false";
 	main_theme_attributes["android:windowSwipeToDismiss"] = bool_to_string(p_preset->get("gesture/swipe_to_dismiss"));
-	main_theme_attributes["android:windowIsTranslucent"] = bool_to_string(should_be_transparent);
-	if (should_be_transparent) {
+	main_theme_attributes["android:windowIsTranslucent"] = bool_to_string(transparency_allowed);
+	if (transparency_allowed) {
 		main_theme_attributes["android:windowBackground"] = "@android:color/transparent";
 	}
 
 	Dictionary splash_theme_attributes;
 	splash_theme_attributes["android:windowSplashScreenBackground"] = "@mipmap/icon_background";
 	splash_theme_attributes["windowSplashScreenAnimatedIcon"] = "@mipmap/icon_foreground";
 	splash_theme_attributes["postSplashScreenTheme"] = "@style/GodotAppMainTheme";
-	splash_theme_attributes["android:windowIsTranslucent"] = bool_to_string(should_be_transparent);
+	splash_theme_attributes["android:windowIsTranslucent"] = bool_to_string(transparency_allowed);
 
 	Dictionary custom_theme_attributes = p_preset->get("gradle_build/custom_theme_attributes");
 
@@ -3000,7 +3000,7 @@ bool EditorExportPlatformAndroid::has_valid_project_configuration(const Ref<Edit
 			}
 		}
 	} else {
-		if (_should_be_transparent(p_preset)) {
+		if (_is_transparency_allowed(p_preset)) {
 			// Warning only, so don't override `valid`.
 			err += vformat(TTR("\"Use Gradle Build\" is required for transparent background on Android"));
 			err += "\n";

platform/android/export/export_plugin.h

@@ -163,7 +163,7 @@ class EditorExportPlatformAndroid : public EditorExportPlatform {
 
 	void _write_tmp_manifest(const Ref<EditorExportPreset> &p_preset, bool p_give_internet, bool p_debug);
 
-	bool _should_be_transparent(const Ref<EditorExportPreset> &p_preset) const;
+	bool _is_transparency_allowed(const Ref<EditorExportPreset> &p_preset) const;
 
 	void _fix_themes_xml(const Ref<EditorExportPreset> &p_preset);
 

platform/android/java/lib/src/org/godotengine/godot/Godot.kt

@@ -38,6 +38,7 @@ import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.content.res.Resources
 import android.graphics.Color
+import android.graphics.PixelFormat
 import android.hardware.Sensor
 import android.hardware.SensorManager
 import android.os.*
@@ -79,6 +80,7 @@ import java.io.FileInputStream
 import java.io.InputStream
 import java.security.MessageDigest
 import java.util.*
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
 
@@ -189,6 +191,13 @@ class Godot(private val context: Context) {
 	private var containerLayout: FrameLayout? = null
 	var renderView: GodotRenderView? = null
 
+	/**
+	 * Stores the flags for the primary window.
+	 *
+	 * @see <a href="https://docs.godotengine.org/en/stable/classes/class_window.html#enum-window-flags">WindowFlags</a>
+	 */
+	private val primaryWindowFlags = ConcurrentHashMap<Int, Boolean>()
+
 	/**
 	 * Returns true if the native engine has been initialized through [onInitNativeLayer], false otherwise.
 	 */
@@ -481,21 +490,32 @@ class Godot(private val context: Context) {
 
 			// Check whether the render view should be made transparent
 			val shouldBeTransparent =
-				!isProjectManagerHint() && !isEditorHint() && java.lang.Boolean.parseBoolean(GodotLib.getGlobal("display/window/per_pixel_transparency/allowed"))
+				!isProjectManagerHint() &&
+					!isEditorHint() &&
+					java.lang.Boolean.parseBoolean(GodotLib.getGlobal("display/window/per_pixel_transparency/allowed")) &&
+					java.lang.Boolean.parseBoolean(GodotLib.getGlobal("display/window/size/transparent"))
 			Log.d(TAG, "Render view should be transparent: $shouldBeTransparent")
 			renderView = if (usesVulkan()) {
 				if (meetsVulkanRequirements(activity.packageManager)) {
-					GodotVulkanRenderView(host, this, godotInputHandler, shouldBeTransparent)
+					GodotVulkanRenderView(host, this, godotInputHandler)
 				} else if (canFallbackToOpenGL()) {
 					// Fallback to OpenGl.
-					GodotGLRenderView(host, this, godotInputHandler, xrMode, useDebugOpengl, shouldBeTransparent)
+					GodotGLRenderView(host, this, godotInputHandler, xrMode, useDebugOpengl)
 				} else {
 					throw IllegalStateException(activity.getString(R.string.error_missing_vulkan_requirements_message))
 				}
 
 			} else {
 				// Fallback to OpenGl.
-				GodotGLRenderView(host, this, godotInputHandler, xrMode, useDebugOpengl, shouldBeTransparent)
+				GodotGLRenderView(host, this, godotInputHandler, xrMode, useDebugOpengl)
+			}
+			if (shouldBeTransparent) {
+				/* By default, GLSurfaceView() creates a RGB_565 opaque surface.
+				 * If we want a translucent one, we should change the surface's
+				 * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
+				 * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
+				 */
+				renderView?.setPixelFormat(PixelFormat.TRANSLUCENT)
 			}
 
 			if (host == primaryHost) {
@@ -1204,4 +1224,23 @@ class Godot(private val context: Context) {
 	private fun nativeOnEditorWorkspaceSelected(workspace: String) {
 		primaryHost?.onEditorWorkspaceSelected(workspace)
 	}
+
+	@Keep
+	private fun setWindowFlag(flag: Int, enabled: Boolean) {
+		primaryWindowFlags[flag] = enabled
+		if (flag == 3 /* WINDOW_FLAG_TRANSPARENT */) {
+			runOnUiThread {
+				val pixelFormat = if (enabled) {
+					PixelFormat.TRANSLUCENT
+				} else {
+					PixelFormat.OPAQUE
+				}
+				Log.d(TAG, "Updating pixel format to $pixelFormat")
+				renderView?.setPixelFormat(pixelFormat)
+			}
+		}
+	}
+
+	@Keep
+	private fun getWindowFlag(flag: Int): Boolean = primaryWindowFlags[flag] ?: false
 }

platform/android/java/lib/src/org/godotengine/godot/GodotGLRenderView.java

@@ -45,7 +45,6 @@
 import android.content.res.AssetManager;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
-import android.graphics.PixelFormat;
 import android.text.TextUtils;
 import android.util.SparseArray;
 import android.view.KeyEvent;
@@ -82,15 +81,15 @@ class GodotGLRenderView extends GLSurfaceView implements GodotRenderView {
 	private final GodotRenderer godotRenderer;
 	private final SparseArray<PointerIcon> customPointerIcons = new SparseArray<>();
 
-	public GodotGLRenderView(GodotHost host, Godot godot, GodotInputHandler inputHandler, XRMode xrMode, boolean useDebugOpengl, boolean shouldBeTranslucent) {
+	public GodotGLRenderView(GodotHost host, Godot godot, GodotInputHandler inputHandler, XRMode xrMode, boolean useDebugOpengl) {
 		super(host.getActivity());
 
 		this.host = host;
 		this.godot = godot;
 		this.inputHandler = inputHandler;
 		this.godotRenderer = new GodotRenderer();
 		setPointerIcon(PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_DEFAULT));
-		init(xrMode, shouldBeTranslucent, useDebugOpengl);
+		init(xrMode, useDebugOpengl);
 	}
 
 	@Override
@@ -236,7 +235,7 @@ public PointerIcon onResolvePointerIcon(MotionEvent me, int pointerIndex) {
 		return getPointerIcon();
 	}
 
-	private void init(XRMode xrMode, boolean translucent, boolean useDebugOpengl) {
+	private void init(XRMode xrMode, boolean useDebugOpengl) {
 		setPreserveEGLContextOnPause(true);
 		setFocusableInTouchMode(true);
 		switch (xrMode) {
@@ -253,15 +252,6 @@ private void init(XRMode xrMode, boolean translucent, boolean useDebugOpengl) {
 
 			case REGULAR:
 			default:
-				/* By default, GLSurfaceView() creates a RGB_565 opaque surface.
-				 * If we want a translucent one, we should change the surface's
-				 * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
-				 * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
-				 */
-				if (translucent) {
-					this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
-				}
-
 				/* Setup the context factory for 2.0 rendering.
 				 * See ContextFactory class definition below
 				 */

platform/android/java/lib/src/org/godotengine/godot/GodotRenderView.java

@@ -71,4 +71,17 @@ default boolean canCapturePointer() {
 		// Pointer capture is not supported on native XR devices.
 		return !DeviceUtils.isNativeXRDevice(getView().getContext()) && getInputHandler().canCapturePointer();
 	}
+
+	/**
+	 * Update the render view pixel format.
+	 * @param format A constant from PixelFormat.
+	 *
+	 * @see android.view.SurfaceHolder#setFormat(int)
+	 */
+	default void setPixelFormat(int format) {
+		SurfaceView surfaceView = getView();
+		if (surfaceView != null && surfaceView.getHolder() != null) {
+			surfaceView.getHolder().setFormat(format);
+		}
+	}
 }

platform/android/java/lib/src/org/godotengine/godot/GodotVulkanRenderView.java

@@ -38,7 +38,6 @@
 import android.content.res.AssetManager;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
-import android.graphics.PixelFormat;
 import android.text.TextUtils;
 import android.util.SparseArray;
 import android.view.KeyEvent;
@@ -57,7 +56,7 @@ class GodotVulkanRenderView extends VkSurfaceView implements GodotRenderView {
 	private final VkRenderer mRenderer;
 	private final SparseArray<PointerIcon> customPointerIcons = new SparseArray<>();
 
-	public GodotVulkanRenderView(GodotHost host, Godot godot, GodotInputHandler inputHandler, boolean shouldBeTranslucent) {
+	public GodotVulkanRenderView(GodotHost host, Godot godot, GodotInputHandler inputHandler) {
 		super(host.getActivity());
 
 		this.host = host;
@@ -67,10 +66,6 @@ public GodotVulkanRenderView(GodotHost host, Godot godot, GodotInputHandler inpu
 		setPointerIcon(PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_DEFAULT));
 		setFocusableInTouchMode(true);
 		setClickable(false);
-
-		if (shouldBeTranslucent) {
-			this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
-		}
 	}
 
 	@Override

platform/android/java_godot_wrapper.cpp

@@ -94,6 +94,8 @@ GodotJavaWrapper::GodotJavaWrapper(JNIEnv *p_env, jobject p_activity, jobject p_
 	_enable_immersive_mode = p_env->GetMethodID(godot_class, "nativeEnableImmersiveMode", "(Z)V");
 	_is_in_immersive_mode = p_env->GetMethodID(godot_class, "isInImmersiveMode", "()Z");
 	_on_editor_workspace_selected = p_env->GetMethodID(godot_class, "nativeOnEditorWorkspaceSelected", "(Ljava/lang/String;)V");
+	_set_window_flag = p_env->GetMethodID(godot_class, "setWindowFlag", "(IZ)V");
+	_get_window_flag = p_env->GetMethodID(godot_class, "getWindowFlag", "(I)Z");
 }
 
 GodotJavaWrapper::~GodotJavaWrapper() {
@@ -599,3 +601,20 @@ void GodotJavaWrapper::on_editor_workspace_selected(const String &p_workspace) {
 		env->CallVoidMethod(godot_instance, _on_editor_workspace_selected, j_workspace);
 	}
 }
+
+void GodotJavaWrapper::set_window_flag(DisplayServer::WindowFlags p_flag, bool p_enabled) {
+	if (_set_window_flag) {
+		JNIEnv *env = get_jni_env();
+		ERR_FAIL_NULL(env);
+		env->CallVoidMethod(godot_instance, _set_window_flag, p_flag, p_enabled);
+	}
+}
+
+bool GodotJavaWrapper::get_window_flag(DisplayServer::WindowFlags p_flag) {
+	if (_get_window_flag) {
+		JNIEnv *env = get_jni_env();
+		ERR_FAIL_NULL_V(env, false);
+		return env->CallBooleanMethod(godot_instance, _get_window_flag, p_flag);
+	}
+	return false;
+}

platform/android/java_godot_wrapper.h

@@ -34,6 +34,7 @@
 
 #include "core/math/color.h"
 #include "core/templates/list.h"
+#include "servers/display_server.h"
 
 #include <android/log.h>
 #include <jni.h>
@@ -84,6 +85,8 @@ class GodotJavaWrapper {
 	jmethodID _enable_immersive_mode = nullptr;
 	jmethodID _is_in_immersive_mode = nullptr;
 	jmethodID _on_editor_workspace_selected = nullptr;
+	jmethodID _set_window_flag = nullptr;
+	jmethodID _get_window_flag = nullptr;
 
 public:
 	GodotJavaWrapper(JNIEnv *p_env, jobject p_activity, jobject p_godot_instance);
@@ -139,4 +142,7 @@ class GodotJavaWrapper {
 	bool is_in_immersive_mode();
 
 	void on_editor_workspace_selected(const String &p_workspace);
+
+	void set_window_flag(DisplayServer::WindowFlags p_flag, bool p_enabled);
+	bool get_window_flag(DisplayServer::WindowFlags p_flag);
 };