JavaFXPorts

On Android, the situation is as follows:

The gradle build script in the android-tools directory creates the setup for an Android Project. It will set up all the links to your classes (including libraries you depend on) and to the javafx-dalvik SDK containing the JavaFX classes and the native libraries for these JavaFX classes.

Running ant debug in this directory will call the Android SDK tools to create an android Package. This is shown below:

To do…

The JavaFXMobile plugin adds a number of tasks to your Java Application that allow you to create packages that can be uploaded to the Apple AppStore and the Android Play Store. You can also execute your applications on the devices, in order to test them. The JavaFXMobile plugin will download and install the JavaFX SDKs for iOS and Android. The source code for those SDKs is available here. Zipped versions of the SDKs are uploaded to maven central, and downloaded by the JavaFXMobile plugin. In order to create an Android application, the Android SDK is needed. You download and install the Android SDK as described above. The location where you install the Android SDK has to be supplied to the plugin as explained before. The plugin will then execute a number of commands that will lead to the creation of an Android package (apk) in the directory build/javafxports/android. On iOS, the situation is internally different — but the gradle commands are similar. The plugin will download and install the RoboVM compiler, and it will use RoboVM compiler commands to create an iOS application in build/javafxports/ios.

In case you’re interested in the source code for the JavaFXMobile plugin, you can check it out here

By convention, the project directory structure should be as follows:

Java code and resources contained in these directories will be shared across all supported platforms. If you want to write code for a specific platform, you will need to add extra directories for them. The jfxmobile plugin will automatically provide the correct classpath dependencies for each different platform, when you write code in the designated platform directory. Below is a listing of the directories that are picked up by the jfxmobile plugin by default.

The difference between assets and resources is that the files that are included in src/…/resources are automatically added to the classpath of the application, while assets are added as platform specific resources. On Android, assets are the same as the regular Android assets resources. On iOS, assets are the same as iOS resource files.

To build a gradle project, you need a build.gradle script. The build.gradle file should be created at the root of your project structure. To apply the jfxmobile plugin to your gradle project, add the following lines at the top of the script:

The next required step is to specify your main class name. This is the class that extends the JavaFX Application object. The name of the property is mainClassName:

For the Android and Desktop platforms you are now good to go. If you also want to run on iOS, there is one final required configuration to set:

This is required because the iOS port of JavaFX will load the main class at runtime. Therefor it is not visible by default when calling the RoboVM compiler. The forceLinkClasses property ensures that those classes are linked in during RoboVM compilation.

As the last step we need to create the actual JavaFX application main class. Below shows the code that should be included as a bare minimum for the application to behave correctly.

The width and height of the Scene should be set to the width and height of the visual bounds of the device’s screen to ensure that the application is properly sized when starting it.

Finally we can build the application and run it on our platforms. To run a gradle build, just type gradle followed by the desired task name, e.g. gradle build. Run gradle tasks to get an overview of the gradle tasks that are available in your project. The jfxmobile plugin will add the following platform specific tasks to your project:

Apart from the default dependency configurations compile and runtime, the jfxmobile plugin adds extra configurations for each supported platform. This allows developers to add dependencies that should only applied to a specific platform. The names of the platform specific configurations are platformCompile and platformRuntime where platform can be one of the following: android, ios or desktop.

For instance, if your android code wants to do some json processing, you configure the dependencies as follows:

A lot of the configuration properties for iOS can be directly overruled using gradle properties. For instance, instead of specifying the debug in the build.gradle file, you can run gradle as follows to enable debugging: gradle -Probovm.debug=true -Probovm.debugPort=9000 launchIPhoneSimulator. Below follows a list of properties that can be overruled by which gradle property:

Finally, two more gradle properties can be provided when launching the iOS simulator to specify which device name and sdk version the simulator should run.

To get a list of possible device names and matching sdk versions, you can run the command ios-sim showdevicetypes. When you’ve run one of the iOS tasks at least once, this command can be found in your local maven repository (which by default is located in your user home directory .m2/repository) under org/robovm/robovm-dist/ROBOVM_VERSION/unpacked/robovm-ROBOVM_VERSION/bin (replace ROBOVM_VERSION with the version used by the jfxmobile plugin).

This is a very simple application that can be executed both on iOS and on Android. We start with a very simple example containing a single class, showing a Button and a Label in a JavaFX StackPane. The example is a maven project taken from the Pro JavaFX 8 book.

The source code is in src/main/java

The JavaFX code for the class is shown below and should be placed in src/main/java/projavafx/SimplePort.java

You can paste this in your favourite IDE, or you can use a text editor.

You can build the project using

mvn clean install

In this example, we show how you can use the Android NFC API. The same principles apply to other Android API’s as well. Of course, this will only work on phones that have an NFC reader. The code for this example is in a bitbucket repository at https://bitbucket.org/johanvos/androidnfcreader.

This code is not optimized at all, and it contains some experiments that are not relevant in this example, but I already wanted to share it since I got questions from people on how to use Android API’s in JavaFX code.

The key to the Android API’s is provided by the FXActivity class. This class is provided in the jfxdvk.jar that is part of the JavaFX Android SDK. Together with your application code and a number of other libraries, this class will be packaged into the .apk file that eventually will be sent to the Android devices. The FXActivity class extends the Android Context class, and thus provide the access to the Android services. The following code will register a listener for NFC events:

We first have to obtain a reference to the NfcAdapter, which is obtained via

NfcAdapter nfcAdapter = NfcAdapter.getDefaultAdapter(ctx);

The javadoc for the NfcAdapter can be found here. We now instruct the NfcAdapter to only read when we are in the foreground, and we want to indicate that we provide a callback method, since our application implements the NfcAdapter.ReaderCallback interface:

nfcAdapter.enableReaderMode(FXActivity.getInstance(), this, NfcAdapter.FLAG_READER_NFC_A, Bundle.EMPTY);

The second parameter, “this” is the callback interface. In case the NFCAdapter detects a card, it will call the onTagDiscovered method on our class, providing a Tag instance. In our example, we start a silly animation that allows you to order some coffee. Smart people are most likely capable of doing something more useful.

Questions, remarks, comments? Please post them in our discussion group at here .