JavaFXPorts jfxmobile-plugin 未找到特定于平台的目录

Question

I have a JavaFX-based interface which I'm trying to build on multiple platforms using JavaFXPorts. Most of the code is platform-independent, but I have some utilities that call platform-specific code, eg for file system locations on Android vs desktop. For example, in the MCVE below: building with gradle desktop or gradle android , I get:

src/main/java/com/example/project/MyApp.java:30: error: cannot find symbol
        platformGreeting = new Label("hello, " + Util.getPlatform());
                                                 ^
  symbol:   variable Util
  location: class MyScene

But if I put both source files ( MyApp.java and Util.java ) together in any of the source directories ( main , desktop , android ) and run the corresponding task, it will build.

In the examples I've seen, they always implement a platform-independent interface under src/main , then implement it in each of the platform-specific directories, but I don't see why this should be necessary.

├── build.gradle
├── settings.gradle
└── src
    ├── android
    │   └── java
    │       └── com
    │           └── example
    │               └── project
    │                   └── Util.java
    ├── desktop
    │   └── java
    │       └── com
    │           └── example
    │               └── project
    │                   └── Util.java
    └── main
        └── java
            └── com
                └── example
                    └── project
                        └── MyApp.java

build.gradle:

buildscript {
    repositories {
        jcenter()
    }

    dependencies {
        classpath 'org.javafxports:jfxmobile-plugin:1.3.10'
    }
}

apply plugin: 'org.javafxports.jfxmobile'

mainClassName = 'com.example.project.MyApp'

repositories {
    jcenter()
}

dependencies {
}

jfxmobile {
    ios {
        forceLinkClasses = [ 'com.example.project.**.*' ]
    }

    android {
        applicationPackage = 'com.example.project'
    }
}

settings.gradle:

rootProject.name = 'project'

src/main/java/com/example/project/MyApp.java:

package com.example.project;

import javafx.application.Application;
import javafx.geometry.HPos;
import javafx.geometry.VPos;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.control.Label;
import javafx.scene.layout.Region;

public class MyApp extends Application {
    private Scene scene;

    @Override public void start(Stage stage) {
        stage.setTitle("MyApp");
        scene = new Scene(new MyScene(), 750, 500);
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

class MyScene extends Region {
    final Label platformGreeting = new Label("hello, " + Util.getPlatform());

    public MyScene() {
        getChildren().add(platformGreeting);
    }

    @Override protected void layoutChildren() {
        double w = getWidth();
        double h = getHeight();
        layoutInArea(platformGreeting, 0, 0, w, h, 0, HPos.CENTER, VPos.CENTER);
    }

    @Override protected double computePrefWidth(double height) {
        return 750;
    }

    @Override protected double computePrefHeight(double width) {
        return 500;
    }
}

src/desktop/java/com/example/project/Util.java:

package com.example.project;

public final class Util {
    private Util() {
        throw new UnsupportedOperationException();
    }

    public static final String getPlatform() {
        return "desktop";
    }
}

src/android/java/com/example/project/Util.java:

package com.example.project;

public final class Util {
    private Util() {
        throw new UnsupportedOperationException();
    }

    public static final String getPlatform() {
        return "android";
    }
}

Answer 1

By the way the source sets are defined in JavaFXPorts, main is shared by all the platforms, and then each specific package is used by the given platform, ie desktop only on Desktop.

As main code is shared by all platforms, it can't contain specific platform code, and it doesn't really know about the platform code that was added to any of the platforms.

This is why you get the compilation exception when trying to add Util to main .

Solution 1

A first approach can be done with Class.forName(className) . On runtime, it will try to find the given class in the class path.

So this should initially work:

    try {
        Class<?> util = Class.forName("com.example.project.Util");
    } catch (ClassNotFoundException ex) {
        Logger.getLogger(BasicView.class.getName()).log(Level.SEVERE, null, ex);
    }

but then you have a problem: you can't really cast to Util in the main package.

One possible solution is just using reflection:

    try {
        Class<?> util = Class.forName("com.example.project.Util");
        Object newInstance = util.newInstance();
        Method method = util.getDeclaredMethod("getPlatform");
        String platform = (String) method.invoke(newInstance);
        System.out.println("Platform: " + platform));
    } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
        Logger.getLogger(BasicView.class.getName()).log(Level.SEVERE, null, ex);
    }

Where I modified Util for convenience:

public class Util {

    public Util() {
    }

    public final String getPlatform() {
        return "desktop";
    }
}

While this works perfectly fine, it is not very easy to work with.

Solution 2

So let's add some neutral API to the main package, something that we can call more easily: an interface with our method of interest:

public interface Platform {

    String getPlatform();
}

and now let's implement it in our platform classes:

public class Util implements Platform {

    public Util() {
    }

    @Override
    public final String getPlatform() {
        return "desktop";
    }
}

Now things get easier, as now you can get a Platform instance, and call getPlatform() :

    try {
        Class<?> util = Class.forName("com.gluonhq.forname.Util");
        Platform platform = (Platform) util.newInstance();
        System.out.println("Platform: " + platform.getPlatform());
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
        Logger.getLogger(BasicView.class.getName()).log(Level.SEVERE, null, ex);
    }

Solution 3: Charm Down

Charm Down is an open source library that provides different native services, with a neutral API that can be used from the main package, on top of the required platform specific code (Java for Desktop, Android or Objective-C for iOS).

Using the Gluon plugin for your IDE, and creating a project that makes use of the jfxmobile plugin will include a few of the services included in Charm Down, as you can see in the build.gradle file:

jfxmobile {
    downConfig {
        version = '3.7.0'
        plugins 'display', 'lifecycle', 'statusbar', 'storage'
    }
    ...
}

If you have a look at how these services are implemented, there is a core plugin with several classes :

• Platform
• Services
• ServicesFactory ...

Now on your project, if you include Charm Down dependencies, you can make use of Platform.getCurrent().name() .

System.out.println("Platform: " + Platform.getCurrent().name());

Not only that, you can get any service just with this:

Services.get(DisplayService.class)
            .ifPresent(display -> System.out.println("Resolution: " + display.getScreenResolution()));

I'd suggest you have a look at how these classes are implemented. And check the different services available so you don't implement them again. Many of the samples available here make use of one or more of those services.

And if you want to implement a new one, I'd suggest you have a look at the Go Native sample ( code and tutorial ).