Question: Using JavaFX Android-specific skins (TextAreaSkinAndroid / TextFieldSkinAndroid) in custom controls with GluonFX / SubstrateVM

[ctoabidmaqbool]

Hi Gluon / JavaFX team 👋

@johanvos @jperedadnr @abhinayagarwal

I know this may not be the perfect repository for this question, but I couldn’t find a more suitable place to ask senior GluonFX / JavaFX experts, so I’m posting here for guidance.

I’m currently working on porting JFoenix to modern JavaFX (17+) with GluonFX, SubstrateVM, and GraalVM, aiming for proper Android support using the latest Gluon toolchain.

🔗 JFoenix (original):
https://github.com/sshahine/JFoenix

🔗 Java 17 port (work in progress):
https://github.com/RationalityFrontline/JFoenix/tree/JFoenix-17.0.0

---

Background

JFoenix previously worked well on Android using the old JavaFXPorts / javafxmobile-plugin stack (Java 8, Dalvik VM, Charm Down, etc.).

With the move to:

• JavaFX 17+
• GluonFX
• Attach
• SubstrateVM / GraalVM

I’m trying to restore proper Android behavior for JFoenix controls.

---

The Problem

While investigating JavaFX Android support, I noticed that JavaFX itself provides Android-specific skins, such as:

• TextAreaSkinAndroid.java
• TextFieldSkinAndroid.java

located here:

🔗 https://github.com/openjdk/jfx/tree/jfx17/modules/javafx.controls/src/android/java/javafx/scene/control/skin

However:

• These classes are not present in the standard JavaFX controls module
• They only exist under the Android-specific source set
• They are not directly accessible from normal JavaFX dependencies

JFoenix also has Android-specific skins, for example:

🔗 https://github.com/sshahine/JFoenix/tree/master/jfoenix/src/main/java/com/jfoenix/android/skins

So my questions are:

---

Questions

1. How are TextAreaSkinAndroid and TextFieldSkinAndroid meant to be used by third-party libraries?

   • Are they intended only for internal JavaFX use?
   • Is there a supported way to depend on them from external controls?

2. When building custom JavaFX controls for Android (via GluonFX), what is the recommended approach?

   • Should we rely on standard skins only?
   • Or provide our own Android-specific skins (as JFoenix previously did)?

3. Is it acceptable (or recommended) to copy or re-implement these Android skins in third-party libraries when targeting Android with SubstrateVM?

4. Which JDK / JavaFX distribution should be used if one needs Android-specific control behavior?

   • Standard OpenJFX binaries?
   • Gluon’s JavaFX builds only?

---

Goal

My goal is to make JFoenix work correctly on Android again, using:

• JavaFX 17+
• GluonFX
• SubstrateVM
• GraalVM

in a way that aligns with current best practices and does not rely on unsupported or fragile internals.

Any guidance, clarification, or recommended direction would be greatly appreciated 🙏

Thank you for your time and for all the great work on JavaFX and Gluon!

[ctoabidmaqbool]

Additional Technical Context (Android skins usage in JFoenix)

To add more technical detail to the issue, here is how JFoenix previously handled Android-specific skins.

In the original JFoenix (JavaFX 8 / JavaFXPorts era), Android support relied directly on JavaFX internal Android skins.

Relevant classes:

• JFXTextFieldSkinAndroid
  https://github.com/sshahine/JFoenix/blob/master/jfoenix/src/main/java/com/jfoenix/android/skins/JFXTextFieldSkinAndroid.java

• JFXTextAreaSkinAndroid
  https://github.com/sshahine/JFoenix/blob/master/jfoenix/src/main/java/com/jfoenix/android/skins/JFXTextAreaSkinAndroid.java

Example (TextArea):

package com.jfoenix.android.skins;

import com.sun.javafx.scene.control.skin.TextAreaSkin;
import com.sun.javafx.scene.control.skin.TextAreaSkinAndroid;

public class JFXTextAreaSkinAndroid extends TextAreaSkinAndroid {
}

And similarly for TextField:

package com.jfoenix.android.skins;

import com.sun.javafx.scene.control.skin.TextFieldSkin;
import com.sun.javafx.scene.control.skin.TextFieldSkinAndroid;

public class JFXTextFieldSkinAndroid<T extends JFXTextField & IFXLabelFloatControl>
        extends TextFieldSkinAndroid {
}

At that time:

• These *SkinAndroid classes were available at runtime
• They were part of the JavaFXPorts / Dalvik-based toolchain
• This approach worked reliably for Android APK builds

---

Current Issue with JavaFX 17+ / GluonFX

With modern JavaFX (17+) and GluonFX / SubstrateVM:

• TextAreaSkinAndroid and TextFieldSkinAndroid exist only in the JavaFX Android source tree
• They are not part of the public JavaFX controls artifacts
• They are not available on the classpath for third-party libraries
• They are located here, but not exposed as usable APIs:

https://github.com/openjdk/jfx/tree/jfx17/modules/javafx.controls/src/android/java/javafx/scene/control/skin

This makes it unclear how libraries like JFoenix are expected to:

• Reuse JavaFX’s Android-specific behavior
• Or properly implement Android skins without duplicating internal logic

---

Clarification Requested

Given the above, I’d really appreciate guidance on:

1. Are TextAreaSkinAndroid / TextFieldSkinAndroid strictly internal and not intended for third-party use?

2. What is the recommended approach for custom control libraries targeting Android via GluonFX?

   • Reimplement Android-specific skins?
   • Rely only on standard skins?

3. Is there any supported way for third-party libraries to hook into JavaFX’s Android control behavior?

4. Is copying or re-implementing these Android skins considered acceptable in the GluonFX/SubstrateVM ecosystem?

The goal is to make JFoenix work correctly and cleanly on Android again, without relying on fragile or unsupported internals.

Thanks again for any clarification or direction from the JavaFX / Gluon team — it would help not only JFoenix, but other control libraries as well 🙏

[jperedadnr]

These skins are needed to hook up the Android software keyboard:

https://github.com/openjdk/jfx/blob/master/modules/javafx.controls/src/android/java/javafx/scene/control/skin/TextFieldSkinAndroid.java

private final EventHandler<MouseEvent> mouseEventListener = e -> {
        if (getSkinnable().isEditable() && getSkinnable().isFocused()) {
            showSoftwareKeyboard();
        }
    };

    private final ChangeListener<Boolean> focusChangeListener = (observable, wasFocused, isFocused) -> {
        if (wasFocused && !isFocused) {
            hideSoftwareKeyboard();
        }
    };

    native void showSoftwareKeyboard();
    native void hideSoftwareKeyboard();

These are installed via -fx-skin:

https://github.com/openjdk/jfx/blob/master/modules/javafx.controls/src/android/resources/com/sun/javafx/scene/control/skin/modena/android.css#L40

.text-field {
    -fx-skin: "javafx.scene.control.skin.TextFieldSkinAndroid";
}

The native implementation is done via Substrate:

https://github.com/gluonhq/substrate/blob/master/src/main/resources/native/android/c/javafx_adapter.c#L133

void showSoftwareKeyboard()
{
    ATTACH_DALVIK();
    LOGE(stderr, "now I have to show keyboard, invoke method %p on env %p\n", activity_showIME, dalvikEnv);
    (*dalvikEnv)->CallStaticVoidMethod(dalvikEnv, activityClass, activity_showIME);
    LOGE(stderr, "I did show keyboard\n");
    DETACH_DALVIK();
}

JNIEXPORT void JNICALL
Java_javafx_scene_control_skin_TextFieldSkinAndroid_showSoftwareKeyboard(JNIEnv *env, jobject textfieldskin)
{
    showSoftwareKeyboard();
}

With this information, you should be able to implement something similar for JFoenix, without needing the Android skins in OpenJFX. Just make sure to use your own skins via -fx-skin (or remove android.css from the stylesheets), and add your own native calls (similar to javafx_adapter.c) to show/hide the keyboard in some .c file in your project, that you can compile, link and add with the GluonFX plugin...