Tudta, hogy a Java segítségével platformokon átívelő mobilalkalmazásokat készíthet? Igen, csípd meg magad, ezt olvastad először! 12 egyszerű lépésben megtanítom az alapjait arra, hogyan használhatja meglévő Java ismereteit előadó alkalmazások létrehozására Android és iOS rendszereken. Mindezt JavaFX eszközzel, GUI eszközkészletként fogjuk megtenni.
De először még néhány előtér. Meg kell felelnie a későbbi követelményeknek ahhoz, hogy alkalmazást készítsen mind Androidra, mind iOS-re. Ha azonban nem szeretne iOS-alkalmazást építeni, nyugodtan fejleszthet bármely olyan Java 64-es gépen, amely támogatja a Java SE 8-at. Ez a projekt egy gradienssel felépített Git-tár lesz. De nem kell Git-tárat létrehozni.
A követelmények a következők :
- A JDK 1.8-nak megfelelő JVM
- Android Parancssori eszközök (SDK v.27)
- XCode 9.2
- Gradle 4.2
- Git Large File Storage (v.2.5.0) (felesleges, ha nem akar git-tárat létrehozni)
- Lehetőleg legalább 4G RAM
Türelmetlen? Szeretné látni a végeredményt? Nézze meg az elkészült projektet alább.
afinlay5 / OnyxFx
Gradle forráskód-tár az OnyxFx-hez, egy többplatformos (Android / iOS / Linux / macOS / Windows) JavaFX alkalmazás-megjelenítéshez ... github.com
Fejlesztői környezetem a Fedora Linux 28 és a macOS High Sierra lesz. Most, hogy ezt elértük, ássunk bele.
1) Hozzon létre egy mappát a projekt elhelyezéséhez
Az OnyxFx projektemet a következőképpen hoztam létre: “ / home / adriandavid / Projects / OnyxFx”. Természetesen szabadon vezetheti a projektet, bárhol is van kedve.
2) Inicializálja a fokozatot, Git, állítsa be a JAVA_HOME beállítást
Nyisson meg egy terminált a projektkönyvtár gyökerében. Ha a gradle megfelelően van konfigurálva, akkor valami ilyesmit kell látnia a következő parancs végrehajtása után:
gradle -v
Győződjön meg arról, hogy a gradle felsorolja-e a Java Development Kit (JDK) 8 telepítését a „JVM” feliratú szakasz mellett.
Bár ennek sokféle módja van, a legegyszerűbb módja annak biztosítása, hogy a JAVA_HOME környezeti változó megfelelően legyen beállítva.
Környezetétől függően erre sokféle lehetőség van. Ennek egyik módja a legtöbb * nix környezetben a változó beállítása az /home//.b ash rc vagy / etc / pro fájlban. Az JAVA_HOME környezeti változó helyes beállításához lásd az operációs rendszer kézikönyvét.
A következő sorokat felveheti a .bashrc vagy a profil végébe annak biztosítása érdekében, hogy a JAVA_HOME helyesen legyen beállítva.
JAVA_HOME=/home/adriandavid/java/oracle_jdk1.8.0_181/export JAVA_HOMEMegjegyzés: Itt telepítheti az Oracle JDK 8-at.
Ezután a következő parancsok egyikének futtatásával ellenőrizze, hogy a héj tükrözi-e a fenti változásokat:
source ~/.bashrcsource /etc/profileÍrja be a következő parancsot a változó helyes beállításának ellenőrzéséhez:
echo $JAVA_HOME
Ha továbbra is nehézségei vannak, vagy a Microsoft Windows rendszert használja, nézze meg itt.
Először futtassa git inita projekt gyökérkönyvtárában a Git tárház inicializálásához. Megjegyzés: ha nem szeretne git-adattárat üzemeltetni, kihagyhatja ezt a lépést.
Másodszor futtassa gradle inita projekt gyökérkönyvtárában a gradle tárház inicializálásához. Erre a lépésre van szükség.
Megjegyzés: Észre fogja venni, hogy az én példám kissé másként jelenik meg. Ez azért van, mert a gradle és a Git már inicializáltam a helyi környezetemet.
3) Legyél durva! Edit gradle.build and
Remélhetőleg a Föld, a Szél és a Tűz segíthet neked! Kapcsolja be kedvenc szövegszerkesztőjét, és szerkessze a projekt gyökérkönyvtárában található build.gradle fájlt, és cserélje le a tartalmát a következő GitHub lényegre.
Ezek a build.gradle beállítások úgy konfigurálják a gradle projektünket, hogy a javafxmobile plugint használja , amely a projekt munkalova . A bővítményről itt és itt tudhat meg többet. Többek között a javafxmobile plugin automatizálja a letöltés folyamatát (a Maven Centralról vagy a jcenterről), valamint az iOS és az Android SDK hozzáadását az alkalmazás osztályútvonalához.
Ha ismeri a fokozatot, a mavenet vagy a hangyát, nagyszerű - valószínűleg van fogalma arról, hogy mi történik. Ha nem ismeri a fokozatot, ne aggódjon miatta . Annyit kell megértenie, hogy a gradle olyan építőeszköz, amelyet az alkalmazások felépítésével kapcsolatos számos feladat automatizálására használnak, például: függőségek megragadása, projektszervezés stb.
Figyelje meg, hogy az Android 7.1 Nougatot (API 25. verzió) és az iOS 11-et célozzuk (hamarosan meglátjuk, hol történik ez). Ezeket az értékeket tetszés szerint módosíthatja. Ne feledje azonban, hogy Android esetén meg kell győződnie arról, hogy az API verzió megegyezik-e az SDK által letöltött verziójával (erről később).
Végül ebben az oktatóanyagban nem fogom bemutatni az aláírt futtatható fájlok készítését. Emiatt az iOSSkipSigning értéke igaz, és nem használjuk a releaseAndroid gradle feladatot. Megadhatja azonban a megfelelő szállást az aláírt alkalmazások előállításához.
4) Készítsen egy új fájlt gradle.properties néven, és konfigurálja azt
Hozzon létre egy új fájlt a projekt gyökérkönyvtárában, gradle.propertiesés adja hozzá a következő tartalmat a fájlhoz.
robovm.device.name=iPhone-7robovm.sdk.version=11.0org.gradle.jvmargs=-Xms4g -Xmx8gThese settings tell the javafxports plugin to use an iPhone-7 as the on-board emulator, to target iOS 11, and to pass the Xms and Xmx flags to the JVM, which specifies both the initial memory pool to 4GB and the maximum heap memory pool to 8GB. This will be necessary for the compilation of the openJDK and the development of the iOS build.
5) Install Homebrew (iOS only)
If you do not have a Mac and are not intending to produce an iOS build, feel free to skip this step.
Open the terminal in macOS and paste the following command.
/usr/bin/ruby -e "$(curl -fsSL //raw.githubusercontent.com/Homebrew/install/master/install)"6) Install the USB Multiplexing Socket (iOS only)
Only move on to this step if Homebrew has successfully installed. If you do not have a Mac and are not intending to produce an iOS build, feel free to skip this step.
Open the terminal in macOS and paste the following command.
brew install usbmuxd7) Grab the Android Command Line Tools
Grab Android Command Line Tools for your platform here. After the download has finished, unzip the folder and paste the contents in the directory of your choice. For me, this was /home//Android.
8) Set Android_HOME, Grab necessary Android packages
As with Java, gradle needs to know where to look to find the Android Command Line Tools. There are a few ways to do this. However, in the spirit of simplicity and consistency, we will set the ANDROID_HOME environmental variable in this tutorial. Add the following variable in the same way that we did it for JAVA_HOME. For example:
ANDROID_HOME=/home/adriandavid/Android/ export ANDROID_HOMERemember to reload the shell by adding source
Now, grab the tools necessary to build the Android build. Execute the following command:
# *.nix./sdkmanager "platform-tools" "build-tools;25.0.3" "platforms;android-25" "extras;android;m2repository" "extras;google;m2repository"or#Windowssdkmanager "platform-tools" "build-tools;25.0.3" "platforms;android-25" "extras;android;m2repository" "extras;google;m2repository"Take careful notice that the SDK and API version we have specified in gradle.build correspond to the version we have specified in this command. Namely, “25”. Should this be misaligned, the build will not succeed.
9) Create the application’s directory structure
To automate the process of creating these directories, execute the following shell script.
Bourne-Again Shell / Korn Shell:
Windows Shell (cmd):
Save the file as mkpdir.bat or mkpdir.sh and execute the file from the project’s root directory as root (or Administrator).
# *.nixchmod +x mkdir.sh-sh ./mkpdir.sh# WindowsmkpdirNotice that we created directories for embedded and desktop. We will produce a desktop build, because it takes no additional work to do so. However, we will not produce any builds for embedded devices.
10) Create your JavaFX Application!
Navigate to /src//java and begin developing your JavaFx application! Application resources are stored in /src//resources.
You can start with a simple Hello World application or look at the source code that I have put together here. OnyxFx is an application I made, following these instructions, that makes REST calls over HTTP to the OnyxFxAPI. The API, in turn, is a web scraper that will return the statistical data (points per game, rebounds per game, assists per game) for the NBA® player and season the client specifies. It returns the data as JSON, which is then parsed and displayed to the screen of the mobile app. Feel free to edit it!
Keep in mind that although you can share source code, you should include custom edits in each copy of the source, should you want to make device specific changes.
Also note that the underlying compiler (MobiDevelop’s fork of RoboVM) does not fully support all Java 8 APIs. If you look very closely at my source code, you will notice that in the iOS version of the source code, I have removed unsupported API such as java.util.function.BiConsumer and java.util.Map.replace().
11) Create a RAM disk for iOS builds (iOS only)
The compilation process for iOS is very resource-heavy, as the plugin will compile the entire openJDK and other libraries twice to create a fat JAR that it will use to build your application. Therefore, you should preemptively create a RAM disk to accommodate for the memory requirements.
This step, however, is subject to your judgement of your machine’s capabilities. For context, the macOS machine that I used to compile my iOS app has 4GB of DDR2 RAM. I decided to make an 8GB RAM disk. To do so, execute the following command in the terminal.
SIZE=8192 ; diskutil erasevolume HFS+ ‘RoboVM RAM Disk’ `hdiutil attach -nomount ram://$((SIZE * 8192))`12) Build and Run your application!
To build your application, execute the gradle wrapper in the root directory from the terminal as follows.
./gradlew clean buildThis will produce a desktop application packaged as a JAR with scripts to run the application provided in /build/distributions/
; and /build/distributions/
Notice that in /bin there are scripts to execute the application. These scripts rely on preserving the current folder structure. Also notice that is not necessary for you to have tree installed. It is used here simply for illustrative purposes.
There is, additionally, a standalone JAR that you can use to execute the application on any desktop environment supporting JavaFX 8. To run the application, execute one of the following:
# Navigate to /build/distributions//
#On *.nixcd bin./
#On Windowscd bin
#Platform agnosticjava -jar OnyxFxMobile.jar (or double click, if jvm is configured to run .jar files)
Note: If the executable providing "java" is not the same vendor and/or version of the Java 8 JDK with which you built this application, the jar may not run. JavaFX 8 builds between the openJDK & Oracle JDK are incompatible.
Otherwise: /location/to/java8/bin/java -jar
View this project’s gradle tasks
You can view this project’s gradle tasks by running the following in the project’s root directory.
./gradlew tasks
To Compile, Run on Desktop
The following command will run your project in the host environment.
./gradlew jar./gradlew run
You will find a standalone jar in build/libs/
t;.jar .
To Compile, Run on Android
./android #Generates a debug Android apk containing the JavaFX application.
./androidInstall #Launch the application on a connected android device.
./androidRelease #Generates a release Android apk containing the JavaFX application.
Note: You will need to configure a valid signingConfig when releasing an APK (javafxports).
You will find two APKs in build/javafxports/android.
The first will be named
t;.apk.
The second will be named -unaligned.apk.
To Compile, Run on iOS
./createIpa - Generates an iOS ipa containing the JavaFX app.
./launchIOSDevice - Launches app on a connected ios device.
./launchIPadSimulator - Launches app on an iPad simulator.
./launchIPhoneSimulator - Launches app on an iPhone simulator.
You will find three executables in build/javafxports/ios.
The first will be named
t;.ipa.
The second will be named
ame>.dSYM.
The third will be named <AppName>.app.
Some screenshots of my sample app
On Desktop
On Android
On iPhone
On iPad
Splash Screen
My Closing Thoughts
javafxports is a promising project that aims to bring JavaFX and the Java SE platform onto mobile and other devices. In a way, the tool parallels Xamarin in its efforts. However, the project has a lot of work left to be done.
For a start, the plugin currently does not fully support Java 8. On Android, it uses retrolambda to handle Java 8 Lambda Expressions & Method References. It technically is up to Java 6. Additional dependencies make it such that you can use Java 8. However, the process is straightforward, the builds work as expected, and the compilation time is not too long.
On iOS, however, the builds are extremely memory-intensive and the compilation process takes a very long time. The following is a snippet of the log for ./gradlew createIpa task.
:createIpa (Thread[Task worker for ‘:’,5,main]) completed. Took 1 hrs 46 mins 40.198 secs.
In total, the process consumed about over 6GB of RAM on my machine. This is hardly ideal. However, the future is promising. A company called Gluon has developed a high performance, fully modular custom JVM fully supporting Java 9, that you can read more about here.
This article is originally published on the blog section of my homepage, here.
Resources to explore:
- JavaFxMobile Plugin Git Repo: //github.com/javafxports/javafxmobile-plugin
- JavaFxPorts Documentation: //docs.gluonhq.com/javafxports/#_how_it_works
- JavaFxPorts Homepage: //javafxports.org/
- Gluon Documentation: //gluonhq.com/developers/documentation/
- Google Groups Page for JavaFxPorts: //groups.google.com/forum/#!forum/javafxports
- StackOverflow Page for JavaFxPorts: //stackoverflow.com/questions/tagged/javafxports
- Gluon Mobile Pricing/License Options: //gluonhq.com/products/mobile/buy/
